diff --git a/BUILD b/BUILD
index ffb5bbdaa1..c6c401c491 100644
--- a/BUILD
+++ b/BUILD
@@ -166,16 +166,6 @@ upb_proto_reflection_library(
     deps = ["descriptor_proto"],
 )
 
-cc_test(
-    name = "test_handlers",
-    srcs = ["tests/test_handlers.c"],
-    deps = [
-        ":descriptor_upbproto",
-        ":upb_pb",
-        ":upb_test",
-    ],
-)
-
 proto_library(
     name = "test_decoder_proto",
     srcs = [
diff --git a/tests/json/test_json.cc b/tests/json/test_json.cc
index b9b50cdc08..b0fd3e3565 100644
--- a/tests/json/test_json.cc
+++ b/tests/json/test_json.cc
@@ -144,7 +144,7 @@ class StringSink {
   }
   ~StringSink() { }
 
-  upb_bytessink* Sink() { return &bytessink_; }
+  upb_bytessink Sink() { return bytessink_; }
 
   const std::string& Data() { return s_; }
 
@@ -169,16 +169,15 @@ class StringSink {
 void test_json_roundtrip_message(const char* json_src,
                                  const char* json_expected,
                                  const upb::Handlers* serialize_handlers,
-                                 const upb::json::ParserMethod* parser_method,
+                                 const upb::json::ParserMethodPtr parser_method,
                                  int seam) {
   VerboseParserEnvironment env(verbose);
   StringSink data_sink;
-  upb::json::Printer* printer = upb::json::Printer::Create(
+  upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
       env.env(), serialize_handlers, data_sink.Sink());
-  upb::json::Parser* parser =
-      upb::json::Parser::Create(
-          env.env(), parser_method, NULL, printer->input(), false);
-  env.ResetBytesSink(parser->input());
+  upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
+      env.env(), parser_method, NULL, printer.input(), false);
+  env.ResetBytesSink(parser.input());
   env.Reset(json_src, strlen(json_src), false, false);
 
   bool ok = env.Start() &&
@@ -203,16 +202,16 @@ void test_json_roundtrip_message(const char* json_src,
 // Starts with a message in JSON format, parses and directly serializes again,
 // and compares the result.
 void test_json_roundtrip() {
-  upb::SymbolTable* symtab = upb::SymbolTable::New();
-  upb::HandlerCache* serialize_handlercache = upb::json::Printer::NewCache(false);
-  upb::json::CodeCache* parse_codecache = upb::json::CodeCache::New();
+  upb::SymbolTable symtab;
+  upb::HandlerCache serialize_handlercache(
+      upb::json::PrinterPtr::NewCache(false));
+  upb::json::CodeCache parse_codecache;
 
-  const upb::MessageDef* md = upb_test_json_TestMessage_getmsgdef(symtab);
+  upb::MessageDefPtr md(upb_test_json_TestMessage_getmsgdef(symtab.ptr()));
   ASSERT(md);
-  const upb::Handlers* serialize_handlers = serialize_handlercache->Get(md);
-  const upb::json::ParserMethod* parser_method = parse_codecache->Get(md);
+  const upb::Handlers* serialize_handlers = serialize_handlercache.Get(md);
+  const upb::json::ParserMethodPtr parser_method = parse_codecache.Get(md);
   ASSERT(serialize_handlers);
-  ASSERT(parser_method);
 
   for (const TestCase* test_case = kTestRoundtripMessages;
        test_case->input != NULL; test_case++) {
@@ -227,9 +226,8 @@ void test_json_roundtrip() {
     }
   }
 
-  upb::HandlerCache::Free(serialize_handlercache);
-  serialize_handlercache = upb::json::Printer::NewCache(true);
-  serialize_handlers = serialize_handlercache->Get(md);
+  serialize_handlercache = upb::json::PrinterPtr::NewCache(true);
+  serialize_handlers = serialize_handlercache.Get(md);
 
   for (const TestCase* test_case = kTestRoundtripMessagesPreserve;
        test_case->input != NULL; test_case++) {
@@ -243,10 +241,6 @@ void test_json_roundtrip() {
                                   serialize_handlers, parser_method, i);
     }
   }
-
-  upb::HandlerCache::Free(serialize_handlercache);
-  upb::json::CodeCache::Free(parse_codecache);
-  upb::SymbolTable::Free(symtab);
 }
 
 extern "C" {
diff --git a/tests/pb/test_decoder.cc b/tests/pb/test_decoder.cc
index d0e3fa3c0d..ec7a788c2e 100644
--- a/tests/pb/test_decoder.cc
+++ b/tests/pb/test_decoder.cc
@@ -279,7 +279,7 @@ int* startstr(int* depth, const uint32_t* num, size_t size_hint) {
 }
 
 size_t value_string(int* depth, const uint32_t* num, const char* buf,
-                    size_t n, const upb::BufferHandle* handle) {
+                    size_t n, const upb_bufhandle* handle) {
   UPB_UNUSED(num);
   UPB_UNUSED(depth);
   check_stack_alignment();
@@ -348,13 +348,13 @@ void free_uint32(void *val) {
 }
 
 template<class T, bool F(int*, const uint32_t*, T)>
-void doreg(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void doreg(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  ASSERT(h->SetValueHandler<T>(f, UpbBindT(F, new uint32_t(num))));
-  if (f->IsSequence()) {
-    ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-    ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+  ASSERT(h.SetValueHandler<T>(f, UpbBind(F, new uint32_t(num))));
+  if (f.IsSequence()) {
+    ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+    ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
   }
 }
 
@@ -368,7 +368,7 @@ uint32_t rep_fn(uint32_t fn) {
 #define UNKNOWN_FIELD 666
 
 template <class T, bool F(int*, const uint32_t*, T)>
-void reg(upb_handlers *h, upb_descriptortype_t type) {
+void reg(upb::HandlersPtr h, upb_descriptortype_t type) {
   // We register both a repeated and a non-repeated field for every type.
   // For the non-repeated field we make the field number the same as the
   // type.  For the repeated field we make it a function of the type.
@@ -376,39 +376,40 @@ void reg(upb_handlers *h, upb_descriptortype_t type) {
   doreg<T, F>(h, rep_fn(type));
 }
 
-void regseq(upb::Handlers* h, const upb::FieldDef* f, uint32_t num) {
-  ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-  ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+void regseq(upb::HandlersPtr h, upb::FieldDefPtr f, uint32_t num) {
+  ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+  ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
 }
 
-void reg_subm(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_subm(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
+  if (f.IsSequence()) regseq(h, f, num);
   ASSERT(
-      h->SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
-  ASSERT(h->SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
+      h.SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
+  ASSERT(h.SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
 }
 
-void reg_str(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_str(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
-  ASSERT(h->SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
-  ASSERT(h->SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
-  ASSERT(h->SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
+  if (f.IsSequence()) regseq(h, f, num);
+  ASSERT(h.SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
+  ASSERT(h.SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
+  ASSERT(h.SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
 }
 
 struct HandlerRegisterData {
   TestMode mode;
 };
 
-void callback(const void *closure, upb_handlers *h) {
+void callback(const void *closure, upb::Handlers* h_ptr) {
+  upb::HandlersPtr h(h_ptr);
   const HandlerRegisterData* data =
       static_cast<const HandlerRegisterData*>(closure);
   if (data->mode == ALL_HANDLERS) {
-    h->SetStartMessageHandler(UpbMakeHandler(startmsg));
-    h->SetEndMessageHandler(UpbMakeHandler(endmsg));
+    h.SetStartMessageHandler(UpbMakeHandler(startmsg));
+    h.SetEndMessageHandler(UpbMakeHandler(endmsg));
 
     // Register handlers for each type.
     reg<double,   value_double>(h, UPB_DESCRIPTOR_TYPE_DOUBLE);
@@ -436,7 +437,7 @@ void callback(const void *closure, upb_handlers *h) {
     reg_subm(h, UPB_DESCRIPTOR_TYPE_MESSAGE);
     reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_MESSAGE));
 
-    if (h->message_def()->full_name() == std::string("DecoderTest")) {
+    if (h.message_def().full_name() == std::string("DecoderTest")) {
       reg_subm(h, UPB_DESCRIPTOR_TYPE_GROUP);
       reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_GROUP));
     }
@@ -446,25 +447,16 @@ void callback(const void *closure, upb_handlers *h) {
   }
 }
 
-upb::reffed_ptr<const upb::Handlers> NewHandlers(upb::SymbolTable* symtab,
-                                                 TestMode mode) {
-  HandlerRegisterData handlerdata;
-  handlerdata.mode = mode;
-  return upb::Handlers::NewFrozen(DecoderTest_getmsgdef(symtab), callback,
-                                  &handlerdata);
-}
-
 /* Running of test cases ******************************************************/
 
 const upb::Handlers *global_handlers;
-const upb::pb::DecoderMethod *global_method;
-
-upb::pb::Decoder* CreateDecoder(upb::Environment* env,
-                                const upb::pb::DecoderMethod* method,
-                                upb::Sink* sink) {
-  upb::pb::Decoder *ret = upb::pb::Decoder::Create(env, method, sink);
-  ASSERT(ret != NULL);
-  ret->set_max_nesting(MAX_NESTING);
+upb::pb::DecoderMethodPtr global_method;
+
+upb::pb::DecoderPtr CreateDecoder(upb::Environment* env,
+                                  upb::pb::DecoderMethodPtr method,
+                                  upb::Sink sink) {
+  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(env, method, sink);
+  ret.set_max_nesting(MAX_NESTING);
   return ret;
 }
 
@@ -479,7 +471,7 @@ uint32_t Hash(const string& proto, const string* expected_output, size_t seam1,
   return hash;
 }
 
-void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
+void CheckBytesParsed(upb::pb::DecoderPtr decoder, size_t ofs) {
   // We can't have parsed more data than the decoder callback is telling us it
   // parsed.
   ASSERT(decoder.BytesParsed() <= ofs);
@@ -491,7 +483,7 @@ void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
 }
 
 static bool parse(VerboseParserEnvironment* env,
-                  const upb::pb::Decoder& decoder, int bytes) {
+                  upb::pb::DecoderPtr decoder, int bytes) {
   CheckBytesParsed(decoder, env->ofs());
   bool ret = env->ParseBuffer(bytes);
   if (ret) {
@@ -501,11 +493,11 @@ static bool parse(VerboseParserEnvironment* env,
   return ret;
 }
 
-void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
+void do_run_decoder(VerboseParserEnvironment* env, upb::pb::DecoderPtr decoder,
                     const string& proto, const string* expected_output,
                     size_t i, size_t j, bool may_skip) {
   env->Reset(proto.c_str(), proto.size(), may_skip, expected_output == NULL);
-  decoder->Reset();
+  decoder.Reset();
 
   testhash = Hash(proto, expected_output, i, j, may_skip);
   if (filter_hash && testhash != filter_hash) return;
@@ -515,7 +507,7 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
     if (filter_hash) {
       fprintf(stderr, "RUNNING TEST CASE, hash=%x\n", testhash);
       fprintf(stderr, "JIT on: %s\n",
-              global_method->is_native() ? "true" : "false");
+              global_method.is_native() ? "true" : "false");
       fprintf(stderr, "Input (len=%u): ", (unsigned)proto.size());
       PrintBinary(proto);
       fprintf(stderr, "\n");
@@ -534,9 +526,9 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
     }
 
     bool ok = env->Start() &&
-              parse(env, *decoder, i) &&
-              parse(env, *decoder, j - i) &&
-              parse(env, *decoder, -1) &&
+              parse(env, decoder, i) &&
+              parse(env, decoder, j - i) &&
+              parse(env, decoder, -1) &&
               env->End();
 
     ASSERT(env->CheckConsistency());
@@ -564,8 +556,8 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
 void run_decoder(const string& proto, const string* expected_output) {
   VerboseParserEnvironment env(filter_hash != 0);
   upb::Sink sink(global_handlers, &closures[0]);
-  upb::pb::Decoder *decoder = CreateDecoder(env.env(), global_method, &sink);
-  env.ResetBytesSink(decoder->input());
+  upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+  env.ResetBytesSink(decoder.input());
   for (size_t i = 0; i < proto.size(); i++) {
     for (size_t j = i; j < UPB_MIN(proto.size(), i + 5); j++) {
       do_run_decoder(&env, decoder, proto, expected_output, i, j, true);
@@ -883,9 +875,9 @@ void test_valid() {
     upb::Environment env;
     env.ReportErrorsTo(&status);
     upb::Sink sink(global_handlers, &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(&env, global_method, &sink);
+    upb::pb::DecoderPtr decoder = CreateDecoder(&env, global_method, sink);
     output.clear();
-    bool ok = upb::BufferSource::PutBuffer("", 0, decoder->input());
+    bool ok = upb::PutBuffer(std::string(), decoder.input());
     ASSERT(ok);
     ASSERT(status.ok());
     if (test_mode == ALL_HANDLERS) {
@@ -1133,23 +1125,22 @@ void test_valid() {
   run_decoder(buf, &textbuf);
 }
 
-upb::reffed_ptr<const upb::pb::DecoderMethod> NewMethod(
-    const upb::Handlers* dest_handlers, bool allow_jit) {
-  upb::pb::CodeCache cache;
-  cache.set_allow_jit(allow_jit);
-  return cache.GetDecoderMethod(upb::pb::DecoderMethodOptions(dest_handlers));
-}
+void empty_callback(const void *closure, upb::Handlers* h_ptr) {}
 
 void test_emptyhandlers(upb::SymbolTable* symtab, bool allowjit) {
   // Create an empty handlers to make sure that the decoder can handle empty
   // messages.
-  const upb::MessageDef* md = Empty_getmsgdef(symtab);
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md));
-  bool ok = h->Freeze(NULL);
-  ASSERT(ok);
-upb::reffed_ptr<const upb::pb::DecoderMethod> method =
-      NewMethod(h.get(), allowjit);
-  ASSERT(method.get());
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
+
+  upb::HandlerCache handler_cache(empty_callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
+
+  pb_code_cache.set_allow_jit(allowjit);
+
+  upb::MessageDefPtr md = upb::MessageDefPtr(Empty_getmsgdef(symtab->ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
 
   // TODO: also test the case where a message has fields, but the fields are
   // submessage fields and have no handlers. This also results in a decoder
@@ -1169,9 +1160,9 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
   };
   for (int i = 0; testdata[i].data; i++) {
     VerboseParserEnvironment env(filter_hash != 0);
-    upb::Sink sink(method->dest_handlers(), &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(env.env(), method.get(), &sink);
-    env.ResetBytesSink(decoder->input());
+    upb::Sink sink(global_method.dest_handlers(), &closures[0]);
+    upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+    env.ResetBytesSink(decoder.input());
     env.Reset(testdata[i].data, testdata[i].length, true, false);
     ASSERT(env.Start());
     ASSERT(env.ParseBuffer(-1));
@@ -1181,24 +1172,25 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
 }
 
 void run_tests(bool use_jit) {
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
-  upb::SymbolTable* symtab = upb::SymbolTable::New();
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
 
-  handlers = NewHandlers(symtab, test_mode);
-  global_handlers = handlers.get();
+  upb::SymbolTable symtab;
+  upb::HandlerCache handler_cache(callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
 
-  method = NewMethod(handlers.get(), use_jit);
-  global_method = method.get();
-  ASSERT(use_jit == global_method->is_native());
+  pb_code_cache.set_allow_jit(use_jit);
+
+  upb::MessageDefPtr md(DecoderTest_getmsgdef(symtab.ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
+  ASSERT(use_jit == global_method.is_native());
   completed = 0;
 
   test_invalid();
   test_valid();
 
-  test_emptyhandlers(symtab, use_jit);
-
-  upb::SymbolTable::Free(symtab);
+  test_emptyhandlers(&symtab, use_jit);
 }
 
 void run_test_suite() {
@@ -1218,9 +1210,6 @@ int run_tests(int argc, char *argv[]) {
     closures[i] = i;
   }
 
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
-
   // Count tests.
   count = &total;
   total = 0;
diff --git a/tests/test_handlers.c b/tests/test_handlers.c
deleted file mode 100644
index 2b19cab431..0000000000
--- a/tests/test_handlers.c
+++ /dev/null
@@ -1,42 +0,0 @@
-
-#include <stdlib.h>
-#include <string.h>
-#include "google/protobuf/descriptor.upbdefs.h"
-#include "upb/handlers.h"
-#include "upb_test.h"
-
-static bool startmsg(void *c, const void *hd) {
-  UPB_UNUSED(c);
-  UPB_UNUSED(hd);
-  return true;
-}
-
-static void test_error() {
-  /* Test creating handlers of a static msgdef. */
-  upb_symtab *s = upb_symtab_new();
-  const upb_msgdef *m = google_protobuf_DescriptorProto_getmsgdef(s);
-  upb_handlers *h = upb_handlers_new(m, &h);
-
-  /* Attempt to set the same handler twice causes error. */
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(!upb_ok(upb_handlers_status(h)));
-  ASSERT(!upb_handlers_freeze(&h, 1, NULL));
-
-  /* Clearing the error will let us proceed. */
-  upb_handlers_clearerr(h);
-  ASSERT(upb_handlers_freeze(&h, 1, NULL));
-  ASSERT(upb_handlers_isfrozen(h));
-
-  upb_handlers_unref(h, &h);
-  upb_symtab_free(s);
-}
-
-int run_tests(int argc, char *argv[]) {
-  UPB_UNUSED(argc);
-  UPB_UNUSED(argv);
-  test_error();
-  return 0;
-}
diff --git a/tests/test_util.h b/tests/test_util.h
index 1b1ff015b0..0b5ddd4805 100644
--- a/tests/test_util.h
+++ b/tests/test_util.h
@@ -78,14 +78,14 @@ class VerboseParserEnvironment {
     if (verbose_) {
       fprintf(stderr, "Calling start()\n");
     }
-    return sink_->Start(len_, &subc_);
+    return sink_.Start(len_, &subc_);
   }
 
   bool End() {
     if (verbose_) {
       fprintf(stderr, "Calling end()\n");
     }
-    end_ok_ = sink_->End();
+    end_ok_ = sink_.End();
     end_ok_set_ = true;
 
     return end_ok_;
@@ -137,7 +137,7 @@ class VerboseParserEnvironment {
               (unsigned)bytes, (unsigned)ofs_, (unsigned)(ofs_ + bytes));
     }
 
-    int parsed = sink_->PutBuffer(subc_, buf2, bytes, &global_handle);
+    int parsed = sink_.PutBuffer(subc_, buf2, bytes, &global_handle);
     free(buf2);
 
     if (verbose_) {
@@ -170,7 +170,7 @@ class VerboseParserEnvironment {
     return true;
   }
 
-  void ResetBytesSink(upb::BytesSink* sink) {
+  void ResetBytesSink(upb::BytesSink sink) {
     sink_ = sink;
   }
 
@@ -181,7 +181,7 @@ class VerboseParserEnvironment {
 
  private:
   upb::Environment env_;
-  upb::BytesSink* sink_;
+  upb::BytesSink sink_;
   const char* buf_;
   size_t len_;
   bool verbose_;
diff --git a/upb/bindings/stdc++/string.h b/upb/bindings/stdc++/string.h
index 4d7a719479..55b44cf095 100644
--- a/upb/bindings/stdc++/string.h
+++ b/upb/bindings/stdc++/string.h
@@ -48,11 +48,12 @@ class StringSink {
   explicit StringSink(T* target) {
     // TODO(haberman): we need to avoid rebuilding a new handler every time,
     // but with class globals disallowed for google3 C++ this is tricky.
+    upb_byteshandler_init(&handler_);
     FillStringHandler<T>::SetHandler(&handler_);
     input_.Reset(&handler_, target);
   }
 
-  BytesSink* input() { return &input_; }
+  BytesSink input() { return input_; }
 
  private:
   upb_byteshandler handler_;
diff --git a/upb/handlers-inl.h b/upb/handlers-inl.h
index b038e30678..5677a4a004 100644
--- a/upb/handlers-inl.h
+++ b/upb/handlers-inl.h
@@ -858,7 +858,7 @@ inline Handler<T>::Handler(F func)
     : registered_(false),
       cleanup_data_(func.GetData()),
       cleanup_func_(func.GetCleanup()) {
-  upb_handlerattr_sethandlerdata(&attr_, func.GetData());
+  attr_.handler_data = func.GetData();
   typedef typename ReturnOf<T>::Return Return;
   typedef typename ConvertParams<F, T>::Func ConvertedParamsFunc;
   typedef typename MaybeWrapReturn<ConvertedParamsFunc, Return>::Func
diff --git a/upb/handlers.c b/upb/handlers.c
index fd81b03528..ba27b9807d 100644
--- a/upb/handlers.c
+++ b/upb/handlers.c
@@ -286,6 +286,10 @@ const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
 
 const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h) { return h->msg; }
 
+bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
+  return upb_handlercache_addcleanup(h->cache, p, func);
+}
+
 upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f) {
   switch (upb_fielddef_type(f)) {
     case UPB_TYPE_INT32:
@@ -470,12 +474,13 @@ void upb_handlercache_free(upb_handlercache *cache) {
   upb_gfree(cache);
 }
 
-bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
+bool upb_handlercache_addcleanup(upb_handlercache *c, void *p,
+                                 upb_handlerfree *func) {
   bool ok;
-  if (upb_inttable_lookupptr(&h->cache->cleanup_, p, NULL)) {
+  if (upb_inttable_lookupptr(&c->cleanup_, p, NULL)) {
     return false;
   }
-  ok = upb_inttable_insertptr(&h->cache->cleanup_, p, upb_value_fptr(func));
+  ok = upb_inttable_insertptr(&c->cleanup_, p, upb_value_fptr(func));
   UPB_ASSERT(ok);
   return true;
 }
diff --git a/upb/handlers.h b/upb/handlers.h
index 4558786b03..44cad18f63 100644
--- a/upb/handlers.h
+++ b/upb/handlers.h
@@ -602,6 +602,8 @@ upb_handlercache *upb_handlercache_new(upb_handlers_callback *callback,
 void upb_handlercache_free(upb_handlercache *cache);
 const upb_handlers *upb_handlercache_get(upb_handlercache *cache,
                                          const upb_msgdef *md);
+bool upb_handlercache_addcleanup(upb_handlercache *h, void *p,
+                                 upb_handlerfree *hfree);
 
 UPB_END_EXTERN_C
 
diff --git a/upb/json/parser.c b/upb/json/parser.c
index 4bc9163187..1dac80003b 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -301,13 +301,13 @@ static void json_parser_any_frame_set_payload_type(
 
   /* Initialize encoder. */
   h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
-  encoder = upb_pb_encoder_create(p->env, h, &frame->stringsink.sink);
+  encoder = upb_pb_encoder_create(p->env, h, frame->stringsink.sink);
 
   /* Initialize parser. */
   parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
   upb_sink_reset(&frame->sink, h, encoder);
   frame->parser = upb_json_parser_create(p->env, parser_method, p->symtab,
-                                         &frame->sink, p->ignore_json_unknown);
+                                         frame->sink, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
@@ -383,9 +383,12 @@ static bool check_stack(upb_json_parser *p) {
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
   const upb_json_codecache *cache = p->method->cache;
-  bool ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
-  const upb_json_parsermethod *method = upb_value_getptr(v);
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
+  method = upb_value_getconstptr(v);
 
   frame->name_table = &method->name_table;
 }
@@ -1287,7 +1290,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
@@ -2416,11 +2419,11 @@ static bool is_string_wrapper_object(upb_json_parser *p) {
  * final state once, when the closing '"' is seen. */
 
 
-#line 2578 "upb/json/parser.rl"
+#line 2581 "upb/json/parser.rl"
 
 
 
-#line 2424 "upb/json/parser.c"
+#line 2427 "upb/json/parser.c"
 static const char _json_actions[] = {
 	0, 1, 0, 1, 1, 1, 3, 1, 
 	4, 1, 6, 1, 7, 1, 8, 1, 
@@ -2667,7 +2670,7 @@ static const int json_en_value_machine = 75;
 static const int json_en_main = 1;
 
 
-#line 2581 "upb/json/parser.rl"
+#line 2584 "upb/json/parser.rl"
 
 size_t parse(void *closure, const void *hd, const char *buf, size_t size,
              const upb_bufhandle *handle) {
@@ -2690,7 +2693,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   capture_resume(parser, buf);
 
   
-#line 2694 "upb/json/parser.c"
+#line 2697 "upb/json/parser.c"
 	{
 	int _klen;
 	unsigned int _trans;
@@ -2765,83 +2768,83 @@ _match:
 		switch ( *_acts++ )
 		{
 	case 1:
-#line 2429 "upb/json/parser.rl"
+#line 2432 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 2:
-#line 2431 "upb/json/parser.rl"
+#line 2434 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 23;goto _again;} }
 	break;
 	case 3:
-#line 2435 "upb/json/parser.rl"
+#line 2438 "upb/json/parser.rl"
 	{ start_text(parser, p); }
 	break;
 	case 4:
-#line 2436 "upb/json/parser.rl"
+#line 2439 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_text(parser, p)); }
 	break;
 	case 5:
-#line 2442 "upb/json/parser.rl"
+#line 2445 "upb/json/parser.rl"
 	{ start_hex(parser); }
 	break;
 	case 6:
-#line 2443 "upb/json/parser.rl"
+#line 2446 "upb/json/parser.rl"
 	{ hexdigit(parser, p); }
 	break;
 	case 7:
-#line 2444 "upb/json/parser.rl"
+#line 2447 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_hex(parser)); }
 	break;
 	case 8:
-#line 2450 "upb/json/parser.rl"
+#line 2453 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(escape(parser, p)); }
 	break;
 	case 9:
-#line 2456 "upb/json/parser.rl"
+#line 2459 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 10:
-#line 2468 "upb/json/parser.rl"
+#line 2471 "upb/json/parser.rl"
 	{ start_duration_base(parser, p); }
 	break;
 	case 11:
-#line 2469 "upb/json/parser.rl"
+#line 2472 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_duration_base(parser, p)); }
 	break;
 	case 12:
-#line 2471 "upb/json/parser.rl"
+#line 2474 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 13:
-#line 2476 "upb/json/parser.rl"
+#line 2479 "upb/json/parser.rl"
 	{ start_timestamp_base(parser, p); }
 	break;
 	case 14:
-#line 2477 "upb/json/parser.rl"
+#line 2480 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
 	break;
 	case 15:
-#line 2479 "upb/json/parser.rl"
+#line 2482 "upb/json/parser.rl"
 	{ start_timestamp_fraction(parser, p); }
 	break;
 	case 16:
-#line 2480 "upb/json/parser.rl"
+#line 2483 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
 	break;
 	case 17:
-#line 2482 "upb/json/parser.rl"
+#line 2485 "upb/json/parser.rl"
 	{ start_timestamp_zone(parser, p); }
 	break;
 	case 18:
-#line 2483 "upb/json/parser.rl"
+#line 2486 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
 	break;
 	case 19:
-#line 2485 "upb/json/parser.rl"
+#line 2488 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 20:
-#line 2490 "upb/json/parser.rl"
+#line 2493 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
           {stack[top++] = cs; cs = 47;goto _again;}
@@ -2853,11 +2856,11 @@ _match:
       }
 	break;
 	case 21:
-#line 2501 "upb/json/parser.rl"
+#line 2504 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 75;goto _again;} }
 	break;
 	case 22:
-#line 2506 "upb/json/parser.rl"
+#line 2509 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_member(parser, p);
@@ -2867,11 +2870,11 @@ _match:
       }
 	break;
 	case 23:
-#line 2513 "upb/json/parser.rl"
+#line 2516 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_membername(parser)); }
 	break;
 	case 24:
-#line 2516 "upb/json/parser.rl"
+#line 2519 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           end_any_member(parser, p);
@@ -2881,7 +2884,7 @@ _match:
       }
 	break;
 	case 25:
-#line 2527 "upb/json/parser.rl"
+#line 2530 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_object(parser, p);
@@ -2891,7 +2894,7 @@ _match:
       }
 	break;
 	case 26:
-#line 2536 "upb/json/parser.rl"
+#line 2539 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           CHECK_RETURN_TOP(end_any_object(parser, p));
@@ -2901,54 +2904,54 @@ _match:
       }
 	break;
 	case 27:
-#line 2548 "upb/json/parser.rl"
+#line 2551 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_array(parser)); }
 	break;
 	case 28:
-#line 2552 "upb/json/parser.rl"
+#line 2555 "upb/json/parser.rl"
 	{ end_array(parser); }
 	break;
 	case 29:
-#line 2557 "upb/json/parser.rl"
+#line 2560 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_number(parser, p)); }
 	break;
 	case 30:
-#line 2558 "upb/json/parser.rl"
+#line 2561 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 31:
-#line 2560 "upb/json/parser.rl"
+#line 2563 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_stringval(parser)); }
 	break;
 	case 32:
-#line 2561 "upb/json/parser.rl"
+#line 2564 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_stringval(parser)); }
 	break;
 	case 33:
-#line 2563 "upb/json/parser.rl"
+#line 2566 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2565 "upb/json/parser.rl"
+#line 2568 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2567 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 36:
-#line 2569 "upb/json/parser.rl"
+#line 2572 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_subobject_full(parser)); }
 	break;
 	case 37:
-#line 2570 "upb/json/parser.rl"
+#line 2573 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
 	case 38:
-#line 2575 "upb/json/parser.rl"
+#line 2578 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
-#line 2952 "upb/json/parser.c"
+#line 2955 "upb/json/parser.c"
 		}
 	}
 
@@ -2965,32 +2968,32 @@ _again:
 	while ( __nacts-- > 0 ) {
 		switch ( *__acts++ ) {
 	case 0:
-#line 2427 "upb/json/parser.rl"
+#line 2430 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; 	if ( p == pe )
 		goto _test_eof;
 goto _again;} }
 	break;
 	case 30:
-#line 2558 "upb/json/parser.rl"
+#line 2561 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 33:
-#line 2563 "upb/json/parser.rl"
+#line 2566 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2565 "upb/json/parser.rl"
+#line 2568 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2567 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 37:
-#line 2570 "upb/json/parser.rl"
+#line 2573 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
-#line 2994 "upb/json/parser.c"
+#line 2997 "upb/json/parser.c"
 		}
 	}
 	}
@@ -2998,7 +3001,7 @@ goto _again;} }
 	_out: {}
 	}
 
-#line 2603 "upb/json/parser.rl"
+#line 2606 "upb/json/parser.rl"
 
   if (p != pe) {
     upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
@@ -3046,13 +3049,13 @@ static void json_parser_reset(upb_json_parser *p) {
 
   /* Emit Ragel initialization of the parser. */
   
-#line 3050 "upb/json/parser.c"
+#line 3053 "upb/json/parser.c"
 	{
 	cs = json_start;
 	top = 0;
 	}
 
-#line 2650 "upb/json/parser.rl"
+#line 2653 "upb/json/parser.rl"
   p->current_state = cs;
   p->parser_top = top;
   accumulate_clear(p);
@@ -3067,7 +3070,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
   upb_msg_field_iter i;
   upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
-  upb_json_parsermethod *m = upb_gmalloc(sizeof(*m));
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
   m->cache = c;
 
@@ -3090,7 +3093,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
     size_t len = upb_fielddef_getjsonname(f, NULL, 0);
     buf = upb_malloc(alloc, len);
     upb_fielddef_getjsonname(f, buf, len);
-    upb_strtable_insert3(&m->name_table, buf, len, v, alloc);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
@@ -3109,7 +3112,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 upb_json_parser *upb_json_parser_create(upb_env *env,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
   const size_t size_before = upb_env_bytesallocated(env);
@@ -3125,8 +3128,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
     p->top->any_frame = json_parser_any_frame_new(p);
@@ -3146,8 +3149,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
 const upb_byteshandler *upb_json_parsermethod_inputhandler(
@@ -3174,21 +3177,22 @@ void upb_json_codecache_free(upb_json_codecache *c) {
   upb_gfree(c);
 }
 
-upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
-                                              const upb_msgdef *md) {
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
-    return upb_value_getptr(v);
+    return upb_value_getconstptr(v);
   }
 
   m = parsermethod_new(c, md);
-  v = upb_value_ptr(m);
+  v = upb_value_constptr(m);
 
   if (!m) return NULL;
-  if (!upb_inttable_insertptr(&c->methods, m, v)) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
 
   /* Populate parser methods for all submessages, so the name tables will
    * be available during parsing. */
diff --git a/upb/json/parser.h b/upb/json/parser.h
index d5ec396dcc..d1a14711f4 100644
--- a/upb/json/parser.h
+++ b/upb/json/parser.h
@@ -14,17 +14,44 @@
 namespace upb {
 namespace json {
 class CodeCache;
-class Parser;
-class ParserMethod;
+class ParserPtr;
+class ParserMethodPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Parser, upb_json_parser)
-UPB_DECLARE_TYPE(upb::json::ParserMethod, upb_json_parsermethod)
-UPB_DECLARE_TYPE(upb::json::CodeCache, upb_json_codecache)
+/* upb_json_parsermethod ******************************************************/
 
-/* upb::json::Parser **********************************************************/
+struct upb_json_parsermethod;
+typedef struct upb_json_parsermethod upb_json_parsermethod;
+
+UPB_BEGIN_EXTERN_C
+
+const upb_byteshandler* upb_json_parsermethod_inputhandler(
+    const upb_json_parsermethod* m);
+
+UPB_END_EXTERN_C
+
+#ifdef __cplusplus
+
+class upb::json::ParserMethodPtr {
+ public:
+  ParserMethodPtr() : ptr_(nullptr) {}
+  ParserMethodPtr(const upb_json_parsermethod* ptr) : ptr_(ptr) {}
+
+  const upb_json_parsermethod* ptr() const { return ptr_; }
+
+  const BytesHandler* input_handler() const {
+    return upb_json_parsermethod_inputhandler(ptr());
+  }
+
+ private:
+  const upb_json_parsermethod* ptr_;
+};
+
+#endif  /* __cplusplus */
+
+/* upb_json_parser ************************************************************/
 
 /* Preallocation hint: parser won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
@@ -32,89 +59,72 @@ UPB_DECLARE_TYPE(upb::json::CodeCache, upb_json_codecache)
  * it may be an underestimate. */
 #define UPB_JSON_PARSER_SIZE 5712
 
+struct upb_json_parser;
+typedef struct upb_json_parser upb_json_parser;
+
+UPB_BEGIN_EXTERN_C
+
+upb_json_parser*
+upb_json_parser_create(upb_env* e, const upb_json_parsermethod* m,
+                       const upb_symtab* symtab, upb_sink output,
+                       bool ignore_json_unknown);
+upb_bytessink upb_json_parser_input(upb_json_parser* p);
+
+UPB_END_EXTERN_C
+
 #ifdef __cplusplus
 
 /* Parses an incoming BytesStream, pushing the results to the destination
  * sink. */
-class upb::json::Parser {
+class upb::json::ParserPtr {
  public:
-  static Parser* Create(Environment* env, const ParserMethod* method,
-                        const SymbolTable* symtab,
-                        Sink* output, bool ignore_json_unknown);
+  ParserPtr(upb_json_parser* ptr) : ptr_(ptr) {}
 
-  BytesSink* input();
+  static ParserPtr Create(Environment* env, ParserMethodPtr method,
+                          SymbolTable* symtab, Sink output,
+                          bool ignore_json_unknown) {
+    upb_symtab* symtab_ptr = symtab ? symtab->ptr() : nullptr;
+    return ParserPtr(upb_json_parser_create(
+        env, method.ptr(), symtab_ptr, output.sink(), ignore_json_unknown));
+  }
 
- private:
-  UPB_DISALLOW_POD_OPS(Parser, upb::json::Parser)
-};
-
-class upb::json::ParserMethod {
- public:
-  /* The input handlers for this decoder method. */
-  const BytesHandler* input_handler() const;
+  BytesSink input() { return upb_json_parser_input(ptr_); }
 
  private:
-  UPB_DISALLOW_POD_OPS(ParserMethod, upb::json::ParserMethod)
+  upb_json_parser* ptr_;
 };
 
-class upb::json::CodeCache {
- public:
-  static CodeCache* New();
-  static void Free(CodeCache* cache);
-
-  /* Returns a DecoderMethod that can push data to the given handlers.
-   * If a suitable method already exists, it will be returned from the cache. */
-  const ParserMethod *Get(const MessageDef* md);
+#endif  /* __cplusplus */
 
- private:
-  UPB_DISALLOW_POD_OPS(CodeCache, upb::json::CodeCache)
-};
+/* upb_json_codecache *********************************************************/
 
-#endif
+struct upb_json_codecache;
+typedef struct upb_json_codecache upb_json_codecache;
 
 UPB_BEGIN_EXTERN_C
 
-upb_json_parser* upb_json_parser_create(upb_env* e,
-                                        const upb_json_parsermethod* m,
-                                        const upb_symtab* symtab,
-                                        upb_sink* output,
-                                        bool ignore_json_unknown);
-upb_bytessink *upb_json_parser_input(upb_json_parser *p);
-
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m);
-
 upb_json_codecache *upb_json_codecache_new();
 void upb_json_codecache_free(upb_json_codecache *cache);
-upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
-                                              const upb_msgdef* md);
+const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
+                                                    const upb_msgdef* md);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
-namespace upb {
-namespace json {
-inline Parser* Parser::Create(Environment* env, const ParserMethod* method,
-                              const SymbolTable* symtab,
-                              Sink* output, bool ignore_json_unknown) {
-  return upb_json_parser_create(
-      env, method, symtab, output, ignore_json_unknown);
-}
-inline BytesSink* Parser::input() {
-  return upb_json_parser_input(this);
-}
-
-inline const BytesHandler* ParserMethod::input_handler() const {
-  return upb_json_parsermethod_inputhandler(this);
-}
-/* static */
-inline const ParserMethod* CodeCache::Get(const MessageDef* md) {
-  return upb_json_codecache_get(this, md);
-}
+class upb::json::CodeCache {
+ public:
+  CodeCache() : ptr_(upb_json_codecache_new(), upb_json_codecache_free) {}
 
-}  /* namespace json */
-}  /* namespace upb */
+  /* Returns a DecoderMethod that can push data to the given handlers.
+   * If a suitable method already exists, it will be returned from the cache. */
+  ParserMethodPtr Get(MessageDefPtr md) {
+    return upb_json_codecache_get(ptr_.get(), md.ptr());
+  }
+
+ private:
+  std::unique_ptr<upb_json_codecache, decltype(&upb_json_codecache_free)> ptr_;
+};
 
 #endif
 
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index c2866c9cab..05a9505f2a 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -299,13 +299,13 @@ static void json_parser_any_frame_set_payload_type(
 
   /* Initialize encoder. */
   h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
-  encoder = upb_pb_encoder_create(p->env, h, &frame->stringsink.sink);
+  encoder = upb_pb_encoder_create(p->env, h, frame->stringsink.sink);
 
   /* Initialize parser. */
   parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
   upb_sink_reset(&frame->sink, h, encoder);
   frame->parser = upb_json_parser_create(p->env, parser_method, p->symtab,
-                                         &frame->sink, p->ignore_json_unknown);
+                                         frame->sink, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
@@ -381,9 +381,12 @@ static bool check_stack(upb_json_parser *p) {
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
   const upb_json_codecache *cache = p->method->cache;
-  bool ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
-  const upb_json_parsermethod *method = upb_value_getptr(v);
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
+  method = upb_value_getconstptr(v);
 
   frame->name_table = &method->name_table;
 }
@@ -1285,7 +1288,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
@@ -2661,7 +2664,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
   upb_msg_field_iter i;
   upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
-  upb_json_parsermethod *m = upb_gmalloc(sizeof(*m));
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
   m->cache = c;
 
@@ -2684,7 +2687,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
     size_t len = upb_fielddef_getjsonname(f, NULL, 0);
     buf = upb_malloc(alloc, len);
     upb_fielddef_getjsonname(f, buf, len);
-    upb_strtable_insert3(&m->name_table, buf, len, v, alloc);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
@@ -2703,7 +2706,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 upb_json_parser *upb_json_parser_create(upb_env *env,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
   const size_t size_before = upb_env_bytesallocated(env);
@@ -2719,8 +2722,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
     p->top->any_frame = json_parser_any_frame_new(p);
@@ -2740,8 +2743,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
 const upb_byteshandler *upb_json_parsermethod_inputhandler(
@@ -2768,21 +2771,22 @@ void upb_json_codecache_free(upb_json_codecache *c) {
   upb_gfree(c);
 }
 
-upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
-                                              const upb_msgdef *md) {
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
-    return upb_value_getptr(v);
+    return upb_value_getconstptr(v);
   }
 
   m = parsermethod_new(c, md);
-  v = upb_value_ptr(m);
+  v = upb_value_constptr(m);
 
   if (!m) return NULL;
-  if (!upb_inttable_insertptr(&c->methods, m, v)) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
 
   /* Populate parser methods for all submessages, so the name tables will
    * be available during parsing. */
diff --git a/upb/json/printer.c b/upb/json/printer.c
index b2c9ebde3b..83f1a58e98 100644
--- a/upb/json/printer.c
+++ b/upb/json/printer.c
@@ -13,7 +13,7 @@ struct upb_json_printer {
   upb_sink input_;
   /* BytesSink closure. */
   void *subc_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* We track the depth so that we know when to emit startstr/endstr on the
    * output. */
@@ -87,7 +87,7 @@ strpc *newstrpc_str(upb_handlers *h, const char * str) {
 static void print_data(
     upb_json_printer *p, const char *buf, unsigned int len) {
   /* TODO: Will need to change if we support pushback from the sink. */
-  size_t n = upb_bytessink_putbuf(p->output_, p->subc_, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(&p->output_, p->subc_, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -369,7 +369,7 @@ static bool printer_startmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   start_frame(p);
   return true;
@@ -381,7 +381,7 @@ static bool printer_endmsg(void *closure, const void *handler_data, upb_status *
   UPB_UNUSED(s);
   end_frame(p);
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
   return true;
 }
@@ -770,7 +770,7 @@ static bool printer_startdurationmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -828,7 +828,7 @@ static bool printer_enddurationmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -839,7 +839,7 @@ static bool printer_starttimestampmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -902,7 +902,7 @@ static bool printer_endtimestampmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -914,7 +914,7 @@ static bool printer_startmsg_noframe(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -925,7 +925,7 @@ static bool printer_endmsg_noframe(
   UPB_UNUSED(handler_data);
   UPB_UNUSED(s);
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
   return true;
 }
@@ -1253,7 +1253,7 @@ static void json_printer_reset(upb_json_printer *p) {
 /* Public API *****************************************************************/
 
 upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
-                                          upb_bytessink *output) {
+                                          upb_bytessink output) {
 #ifndef NDEBUG
   size_t size_before = upb_env_bytesallocated(e);
 #endif
@@ -1273,12 +1273,16 @@ upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
   return p;
 }
 
-upb_sink *upb_json_printer_input(upb_json_printer *p) {
-  return &p->input_;
+upb_sink upb_json_printer_input(upb_json_printer *p) {
+  return p->input_;
 }
 
 upb_handlercache *upb_json_printer_newcache(bool preserve_proto_fieldnames) {
   upb_json_printercache *cache = upb_gmalloc(sizeof(*cache));
+  upb_handlercache *ret = upb_handlercache_new(printer_sethandlers, cache);
+
   cache->preserve_fieldnames = preserve_proto_fieldnames;
-  return upb_handlercache_new(printer_sethandlers, cache);
+  upb_handlercache_addcleanup(ret, cache, upb_gfree);
+
+  return ret;
 }
diff --git a/upb/json/printer.h b/upb/json/printer.h
index fe9c8f1fc6..a7a37bb30a 100644
--- a/upb/json/printer.h
+++ b/upb/json/printer.h
@@ -12,44 +12,24 @@
 #ifdef __cplusplus
 namespace upb {
 namespace json {
-class Printer;
+class PrinterPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Printer, upb_json_printer)
-
-
-/* upb::json::Printer *********************************************************/
+/* upb_json_printer ***********************************************************/
 
 #define UPB_JSON_PRINTER_SIZE 192
 
-#ifdef __cplusplus
-
-/* Prints an incoming stream of data to a BytesSink in JSON format. */
-class upb::json::Printer {
- public:
-  static Printer* Create(Environment* env, const upb::Handlers* handlers,
-                         BytesSink* output);
-
-  /* The input to the printer. */
-  Sink* input();
-
-  static const size_t kSize = UPB_JSON_PRINTER_SIZE;
-  static upb_handlercache* NewCache(bool preserve_proto_fieldnames);
-
- private:
-  UPB_DISALLOW_POD_OPS(Printer, upb::json::Printer)
-};
-
-#endif
+struct upb_json_printer;
+typedef struct upb_json_printer upb_json_printer;
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
-                                          upb_bytessink *output);
-upb_sink *upb_json_printer_input(upb_json_printer *p);
+                                          upb_bytessink output);
+upb_sink upb_json_printer_input(upb_json_printer *p);
 const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
                                                  bool preserve_fieldnames,
                                                  const void *owner);
@@ -60,19 +40,29 @@ UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
-namespace upb {
-namespace json {
-inline Printer* Printer::Create(Environment* env, const upb::Handlers* handlers,
-                                BytesSink* output) {
-  return upb_json_printer_create(env, handlers, output);
-}
-inline Sink* Printer::input() { return upb_json_printer_input(this); }
-inline upb_handlercache* Printer::NewCache(bool preserve_proto_fieldnames) {
-  return upb_json_printer_newcache(preserve_proto_fieldnames);
-}
-}  /* namespace json */
-}  /* namespace upb */
+/* Prints an incoming stream of data to a BytesSink in JSON format. */
+class upb::json::PrinterPtr {
+ public:
+  PrinterPtr(upb_json_printer* ptr) : ptr_(ptr) {}
 
-#endif
+  static PrinterPtr Create(Environment *env, const upb::Handlers *handlers,
+                           BytesSink output) {
+    return PrinterPtr(upb_json_printer_create(env, handlers, output.sink()));
+  }
+
+  /* The input to the printer. */
+  Sink input() { return upb_json_printer_input(ptr_); }
+
+  static const size_t kSize = UPB_JSON_PRINTER_SIZE;
+
+  static HandlerCache NewCache(bool preserve_proto_fieldnames) {
+    return upb_json_printer_newcache(preserve_proto_fieldnames);
+  }
+
+ private:
+  upb_json_printer* ptr_;
+};
+
+#endif  /* __cplusplus */
 
 #endif  /* UPB_JSON_TYPED_PRINTER_H_ */
diff --git a/upb/pb/decoder.c b/upb/pb/decoder.c
index 0cae05bc1d..cd64f72fb1 100644
--- a/upb/pb/decoder.c
+++ b/upb/pb/decoder.c
@@ -993,7 +993,7 @@ void upb_pbdecoder_reset(upb_pbdecoder *d) {
 }
 
 upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
-                                    upb_sink *sink) {
+                                    upb_sink sink) {
   const size_t default_max_nesting = 64;
 #ifndef NDEBUG
   size_t size_before = upb_env_bytesallocated(e);
@@ -1017,12 +1017,11 @@ upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
   upb_pbdecoder_reset(d);
   upb_bytessink_reset(&d->input_, &m->input_handler_, d);
 
-  UPB_ASSERT(sink);
   if (d->method_->dest_handlers_) {
-    if (sink->handlers != d->method_->dest_handlers_)
+    if (sink.handlers != d->method_->dest_handlers_)
       return NULL;
   }
-  upb_sink_reset(&d->top->sink, sink->handlers, sink->closure);
+  d->top->sink = sink;
 
   /* If this fails, increase the value in decoder.h. */
   UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
@@ -1038,8 +1037,8 @@ const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d) {
   return d->method_;
 }
 
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d) {
-  return &d->input_;
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d) {
+  return d->input_;
 }
 
 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d) {
diff --git a/upb/pb/decoder.h b/upb/pb/decoder.h
index 1ffcb7dce0..ba381f358b 100644
--- a/upb/pb/decoder.h
+++ b/upb/pb/decoder.h
@@ -56,6 +56,7 @@ UPB_END_EXTERN_C
  * Handlers. */
 class upb::pb::DecoderMethodPtr {
  public:
+  DecoderMethodPtr() : ptr_(nullptr) {}
   DecoderMethodPtr(const upb_pbdecodermethod* ptr) : ptr_(ptr) {}
 
   const upb_pbdecodermethod* ptr() { return ptr_; }
@@ -98,9 +99,9 @@ UPB_BEGIN_EXTERN_C
 
 upb_pbdecoder *upb_pbdecoder_create(upb_env *e,
                                     const upb_pbdecodermethod *method,
-                                    upb_sink *output);
+                                    upb_sink output);
 const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d);
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d);
 uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
 bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
@@ -124,8 +125,8 @@ class upb::pb::DecoderPtr {
    *
    * The sink must match the given method. */
   static DecoderPtr Create(Environment *env, DecoderMethodPtr method,
-                           upb_sink *output) {
-    return DecoderPtr(upb_pbdecoder_create(env, method.ptr(), output));
+                           upb::Sink output) {
+    return DecoderPtr(upb_pbdecoder_create(env, method.ptr(), output.sink()));
   }
 
   /* Returns the DecoderMethod this decoder is parsing from. */
@@ -134,7 +135,7 @@ class upb::pb::DecoderPtr {
   }
 
   /* The sink on which this decoder receives input. */
-  upb_bytessink* input() { return upb_pbdecoder_input(ptr()); }
+  BytesSink input() { return BytesSink(upb_pbdecoder_input(ptr())); }
 
   /* Returns number of bytes successfully parsed.
    *
diff --git a/upb/pb/encoder.c b/upb/pb/encoder.c
index 34970072d7..1496eba710 100644
--- a/upb/pb/encoder.c
+++ b/upb/pb/encoder.c
@@ -95,7 +95,7 @@ struct upb_pb_encoder {
 
   /* Our input and output. */
   upb_sink input_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* The "subclosure" -- used as the inner closure as part of the bytessink
    * protocol. */
@@ -127,7 +127,7 @@ struct upb_pb_encoder {
 
 /* TODO(haberman): handle pushback */
 static void putbuf(upb_pb_encoder *e, const char *buf, size_t len) {
-  size_t n = upb_bytessink_putbuf(e->output_, e->subc, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(&e->output_, e->subc, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -353,7 +353,7 @@ static bool startmsg(void *c, const void *hd) {
   upb_pb_encoder *e = c;
   UPB_UNUSED(hd);
   if (e->depth++ == 0) {
-    upb_bytessink_start(e->output_, 0, &e->subc);
+    upb_bytessink_start(&e->output_, 0, &e->subc);
   }
   return true;
 }
@@ -363,7 +363,7 @@ static bool endmsg(void *c, const void *hd, upb_status *status) {
   UPB_UNUSED(hd);
   UPB_UNUSED(status);
   if (--e->depth == 0) {
-    upb_bytessink_end(e->output_);
+    upb_bytessink_end(&e->output_);
   }
   return true;
 }
@@ -527,7 +527,7 @@ upb_handlercache *upb_pb_encoder_newcache() {
 }
 
 upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
-                                      upb_bytessink *output) {
+                                      upb_bytessink output) {
   const size_t initial_bufsize = 256;
   const size_t initial_segbufsize = 16;
   /* TODO(haberman): make this configurable. */
@@ -556,7 +556,7 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
 
   e->env = env;
   e->output_ = output;
-  e->subc = output->closure;
+  e->subc = output.closure;
   e->ptr = e->buf;
 
   /* If this fails, increase the value in encoder.h. */
@@ -565,4 +565,4 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
   return e;
 }
 
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *e) { return &e->input_; }
+upb_sink upb_pb_encoder_input(upb_pb_encoder *e) { return e->input_; }
diff --git a/upb/pb/encoder.h b/upb/pb/encoder.h
index 20ce606d26..7aa28709a4 100644
--- a/upb/pb/encoder.h
+++ b/upb/pb/encoder.h
@@ -30,16 +30,16 @@ class EncoderPtr;
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the decoder library is upgraded without recompiling the application,
  * it may be an underestimate. */
-#define UPB_PB_ENCODER_SIZE 768
+#define UPB_PB_ENCODER_SIZE 784
 
 struct upb_pb_encoder;
 typedef struct upb_pb_encoder upb_pb_encoder;
 
 UPB_BEGIN_EXTERN_C
 
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *p);
+upb_sink upb_pb_encoder_input(upb_pb_encoder *p);
 upb_pb_encoder* upb_pb_encoder_create(upb_env* e, const upb_handlers* h,
-                                      upb_bytessink* output);
+                                      upb_bytessink output);
 
 upb_handlercache *upb_pb_encoder_newcache();
 
@@ -56,12 +56,12 @@ class upb::pb::EncoderPtr {
   /* Creates a new encoder in the given environment.  The Handlers must have
    * come from NewHandlers() below. */
   static EncoderPtr Create(Environment* env, const Handlers* handlers,
-                         BytesSink* output) {
-    return EncoderPtr(upb_pb_encoder_create(env, handlers, output->ptr()));
+                           BytesSink output) {
+    return EncoderPtr(upb_pb_encoder_create(env, handlers, output.sink()));
   }
 
   /* The input to the encoder. */
-  upb_sink* input() { return upb_pb_encoder_input(ptr()); }
+  upb::Sink input() { return upb_pb_encoder_input(ptr()); }
 
   /* Creates a new set of handlers for this MessageDef. */
   static HandlerCache NewCache() {
diff --git a/upb/sink.c b/upb/sink.c
index d0197a6eed..6ef571838e 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -1,17 +1,17 @@
 
 #include "upb/sink.h"
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink) {
   void *subc;
   bool ret;
   upb_bufhandle handle = UPB_BUFHANDLE_INIT;
   handle.buf = buf;
-  ret = upb_bytessink_start(sink, len, &subc);
+  ret = upb_bytessink_start(&sink, len, &subc);
   if (ret && len != 0) {
-    ret = (upb_bytessink_putbuf(sink, subc, buf, len, &handle) >= len);
+    ret = (upb_bytessink_putbuf(&sink, subc, buf, len, &handle) >= len);
   }
   if (ret) {
-    ret = upb_bytessink_end(sink);
+    ret = upb_bytessink_end(&sink);
   }
   return ret;
 }
diff --git a/upb/sink.h b/upb/sink.h
index 8cab45d7e8..1359c5e1fc 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -237,6 +237,17 @@ class upb::Sink {
   /* Constructor with no initialization; must be Reset() before use. */
   Sink() {}
 
+  Sink(const Sink&) = default;
+  Sink& operator=(const Sink&) = default;
+
+  Sink(const upb_sink& sink) : sink_(sink) {}
+  Sink &operator=(const upb_sink &sink) {
+    sink_ = sink;
+    return *this;
+  }
+
+  upb_sink sink() { return sink_; }
+
   /* Constructs a new sink for the given frozen handlers and closure.
    *
    * TODO: once the Handlers know the expected closure type, verify that T
@@ -406,7 +417,16 @@ class upb::BytesSink {
  public:
   BytesSink() {}
 
-  upb_bytessink* ptr() { return &sink_; }
+  BytesSink(const BytesSink&) = default;
+  BytesSink& operator=(const BytesSink&) = default;
+
+  BytesSink(const upb_bytessink& sink) : sink_(sink) {}
+  BytesSink &operator=(const upb_bytessink &sink) {
+    sink_ = sink;
+    return *this;
+  }
+
+  upb_bytessink sink() { return sink_; }
 
   /* Constructs a new sink for the given frozen handlers and closure.
    *
@@ -444,15 +464,15 @@ class upb::BytesSink {
 
 UPB_BEGIN_EXTERN_C
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink);
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upb {
-template <class T> bool PutBuffer(const T& str, upb_bytessink* sink) {
-  return upb_bufsrc_putbuf(str.c_str(), str.size(), sink);
+template <class T> bool PutBuffer(const T& str, BytesSink sink) {
+  return upb_bufsrc_putbuf(str.c_str(), str.size(), sink.sink());
 }
 }