Convert JsonWriter::Write to taking a const ref for the in-param

Clearer API; flushes out a lot of unnecessary heap allocations.

depends on https://codereview.chromium.org/1129083003/

BUG=none

Review URL: https://codereview.chromium.org/1131113004

Cr-Commit-Position: refs/heads/master@{#330255}

213 files changed, 594 insertions, 629 deletions

diff --git a/android_webview/browser/aw_dev_tools_discovery_provider.cc b/android_webview/browser/aw_dev_tools_discovery_provider.cc
index 4117358..fe1e61e 100644
--- a/android_webview/browser/aw_dev_tools_discovery_provider.cc
+++ b/android_webview/browser/aw_dev_tools_discovery_provider.cc
@@ -35,7 +35,7 @@ std::string GetViewDescription(WebContents* web_contents) {
     description.SetInteger("height", screen_rect.height());
   }
   std::string json;
-  base::JSONWriter::Write(&description, &json);
+  base::JSONWriter::Write(description, &json);
   return json;
 }
 
diff --git a/base/json/json_string_value_serializer.cc b/base/json/json_string_value_serializer.cc
index debf9f0..3787fdb 100644
--- a/base/json/json_string_value_serializer.cc
+++ b/base/json/json_string_value_serializer.cc
@@ -37,7 +37,7 @@ bool JSONStringValueSerializer::SerializeInternal(const Value& root,
   if (pretty_print_)
     options |= base::JSONWriter::OPTIONS_PRETTY_PRINT;
 
-  return base::JSONWriter::WriteWithOptions(&root, options, json_string_);
+  return base::JSONWriter::WriteWithOptions(root, options, json_string_);
 }
 
 JSONStringValueDeserializer::JSONStringValueDeserializer(
diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc
index b8aebe0..61860fd 100644
--- a/base/json/json_value_serializer_unittest.cc
+++ b/base/json/json_value_serializer_unittest.cc
@@ -302,7 +302,7 @@ TEST(JSONValueSerializerTest, StringEscape) {
   std::string output_js;
   DictionaryValue valueRoot;
   valueRoot.SetString("all_chars", all_chars);
-  JSONWriter::Write(&valueRoot, &output_js);
+  JSONWriter::Write(valueRoot, &output_js);
   ASSERT_EQ(expected_output, output_js);
 
   // Test JSONValueSerializer interface (uses JSONWriter).
diff --git a/base/json/json_writer.cc b/base/json/json_writer.cc
index d14c92c..abfead8 100644
--- a/base/json/json_writer.cc
+++ b/base/json/json_writer.cc
@@ -21,12 +21,13 @@ const char kPrettyPrintLineEnding[] = "\n";
 #endif
 
 // static
-bool JSONWriter::Write(const Value* const node, std::string* json) {
+bool JSONWriter::Write(const Value& node, std::string* json) {
   return WriteWithOptions(node, 0, json);
 }
 
 // static
-bool JSONWriter::WriteWithOptions(const Value* const node, int options,
+bool JSONWriter::WriteWithOptions(const Value& node,
+                                  int options,
                                   std::string* json) {
   json->clear();
   // Is there a better way to estimate the size of the output?
@@ -50,8 +51,8 @@ JSONWriter::JSONWriter(int options, std::string* json)
   DCHECK(json);
 }
 
-bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
-  switch (node->GetType()) {
+bool JSONWriter::BuildJSONString(const Value& node, size_t depth) {
+  switch (node.GetType()) {
     case Value::TYPE_NULL: {
       json_string_->append("null");
       return true;
@@ -59,7 +60,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
     case Value::TYPE_BOOLEAN: {
       bool value;
-      bool result = node->GetAsBoolean(&value);
+      bool result = node.GetAsBoolean(&value);
       DCHECK(result);
       json_string_->append(value ? "true" : "false");
       return result;
@@ -67,7 +68,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
     case Value::TYPE_INTEGER: {
       int value;
-      bool result = node->GetAsInteger(&value);
+      bool result = node.GetAsInteger(&value);
       DCHECK(result);
       json_string_->append(IntToString(value));
       return result;
@@ -75,7 +76,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
     case Value::TYPE_DOUBLE: {
       double value;
-      bool result = node->GetAsDouble(&value);
+      bool result = node.GetAsDouble(&value);
       DCHECK(result);
       if (omit_double_type_preservation_ &&
           value <= kint64max &&
@@ -107,7 +108,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
     case Value::TYPE_STRING: {
       std::string value;
-      bool result = node->GetAsString(&value);
+      bool result = node.GetAsString(&value);
       DCHECK(result);
       EscapeJSONString(value, true, json_string_);
       return result;
@@ -120,7 +121,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
       const ListValue* list = NULL;
       bool first_value_has_been_output = false;
-      bool result = node->GetAsList(&list);
+      bool result = node.GetAsList(&list);
       DCHECK(result);
       for (ListValue::const_iterator it = list->begin(); it != list->end();
            ++it) {
@@ -134,7 +135,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
             json_string_->push_back(' ');
         }
 
-        if (!BuildJSONString(value, depth))
+        if (!BuildJSONString(*value, depth))
           result = false;
 
         first_value_has_been_output = true;
@@ -153,7 +154,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
 
       const DictionaryValue* dict = NULL;
       bool first_value_has_been_output = false;
-      bool result = node->GetAsDictionary(&dict);
+      bool result = node.GetAsDictionary(&dict);
       DCHECK(result);
       for (DictionaryValue::Iterator itr(*dict); !itr.IsAtEnd();
            itr.Advance()) {
@@ -176,7 +177,7 @@ bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
         if (pretty_print_)
           json_string_->push_back(' ');
 
-        if (!BuildJSONString(&itr.value(), depth + 1U))
+        if (!BuildJSONString(itr.value(), depth + 1U))
           result = false;
 
         first_value_has_been_output = true;
diff --git a/base/json/json_writer.h b/base/json/json_writer.h
index 9709c7e..5711665 100644
--- a/base/json/json_writer.h
+++ b/base/json/json_writer.h
@@ -38,11 +38,12 @@ class BASE_EXPORT JSONWriter {
   // TODO(tc): Should we generate json if it would be invalid json (e.g.,
   // |node| is not a DictionaryValue/ListValue or if there are inf/-inf float
   // values)? Return true on success and false on failure.
-  static bool Write(const Value* const node, std::string* json);
+  static bool Write(const Value& node, std::string* json);
 
   // Same as above but with |options| which is a bunch of JSONWriter::Options
   // bitwise ORed together. Return true on success and false on failure.
-  static bool WriteWithOptions(const Value* const node, int options,
+  static bool WriteWithOptions(const Value& node,
+                               int options,
                                std::string* json);
 
  private:
@@ -50,7 +51,7 @@ class BASE_EXPORT JSONWriter {
 
   // Called recursively to build the JSON string. When completed,
   // |json_string_| will contain the JSON.
-  bool BuildJSONString(const Value* const node, size_t depth);
+  bool BuildJSONString(const Value& node, size_t depth);
 
   // Adds space to json_string_ for the indent level.
   void IndentLine(size_t depth);
diff --git a/base/json/json_writer_unittest.cc b/base/json/json_writer_unittest.cc
index 5ac2590..0daeafc 100644
--- a/base/json/json_writer_unittest.cc
+++ b/base/json/json_writer_unittest.cc
@@ -12,47 +12,39 @@ TEST(JSONWriterTest, BasicTypes) {
   std::string output_js;
 
   // Test null.
-  EXPECT_TRUE(JSONWriter::Write(Value::CreateNullValue().get(), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(*Value::CreateNullValue(), &output_js));
   EXPECT_EQ("null", output_js);
 
   // Test empty dict.
-  DictionaryValue dict;
-  EXPECT_TRUE(JSONWriter::Write(&dict, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(DictionaryValue(), &output_js));
   EXPECT_EQ("{}", output_js);
 
   // Test empty list.
-  ListValue list;
-  EXPECT_TRUE(JSONWriter::Write(&list, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(ListValue(), &output_js));
   EXPECT_EQ("[]", output_js);
 
   // Test integer values.
-  FundamentalValue int_value(42);
-  EXPECT_TRUE(JSONWriter::Write(&int_value, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(42), &output_js));
   EXPECT_EQ("42", output_js);
 
   // Test boolean values.
-  FundamentalValue bool_value(true);
-  EXPECT_TRUE(JSONWriter::Write(&bool_value, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(true), &output_js));
   EXPECT_EQ("true", output_js);
 
   // Test Real values should always have a decimal or an 'e'.
-  FundamentalValue double_value(1.0);
-  EXPECT_TRUE(JSONWriter::Write(&double_value, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(1.0), &output_js));
   EXPECT_EQ("1.0", output_js);
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  FundamentalValue double_value2(0.2);
-  EXPECT_TRUE(JSONWriter::Write(&double_value2, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(0.2), &output_js));
   EXPECT_EQ("0.2", output_js);
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  FundamentalValue double_value3(-0.8);
-  EXPECT_TRUE(JSONWriter::Write(&double_value3, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(-0.8), &output_js));
   EXPECT_EQ("-0.8", output_js);
 
   // Test String values.
-  StringValue string_value("foo");
-  EXPECT_TRUE(JSONWriter::Write(&string_value, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(StringValue("foo"), &output_js));
   EXPECT_EQ("\"foo\"", output_js);
 }
 
@@ -71,11 +63,10 @@ TEST(JSONWriterTest, NestedTypes) {
   root_dict.Set("list", list.Pass());
 
   // Test the pretty-printer.
-  EXPECT_TRUE(JSONWriter::Write(&root_dict, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(root_dict, &output_js));
   EXPECT_EQ("{\"list\":[{\"inner int\":10},[],true]}", output_js);
-  EXPECT_TRUE(JSONWriter::WriteWithOptions(&root_dict,
-                                           JSONWriter::OPTIONS_PRETTY_PRINT,
-                                           &output_js));
+  EXPECT_TRUE(JSONWriter::WriteWithOptions(
+      root_dict, JSONWriter::OPTIONS_PRETTY_PRINT, &output_js));
 
   // The pretty-printer uses a different newline style on Windows than on
   // other platforms.
@@ -102,13 +93,13 @@ TEST(JSONWriterTest, KeysWithPeriods) {
   scoped_ptr<DictionaryValue> period_dict2(new DictionaryValue());
   period_dict2->SetIntegerWithoutPathExpansion("g.h.i.j", 1);
   period_dict.SetWithoutPathExpansion("d.e.f", period_dict2.Pass());
-  EXPECT_TRUE(JSONWriter::Write(&period_dict, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(period_dict, &output_js));
   EXPECT_EQ("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}", output_js);
 
   DictionaryValue period_dict3;
   period_dict3.SetInteger("a.b", 2);
   period_dict3.SetIntegerWithoutPathExpansion("a.b", 1);
-  EXPECT_TRUE(JSONWriter::Write(&period_dict3, &output_js));
+  EXPECT_TRUE(JSONWriter::Write(period_dict3, &output_js));
   EXPECT_EQ("{\"a\":{\"b\":2},\"a.b\":1}", output_js);
 }
 
@@ -118,9 +109,9 @@ TEST(JSONWriterTest, BinaryValues) {
   // Binary values should return errors unless suppressed via the
   // OPTIONS_OMIT_BINARY_VALUES flag.
   scoped_ptr<Value> root(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  EXPECT_FALSE(JSONWriter::Write(root.get(), &output_js));
+  EXPECT_FALSE(JSONWriter::Write(*root, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
-      root.get(), JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
+      *root, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_TRUE(output_js.empty());
 
   ListValue binary_list;
@@ -129,9 +120,9 @@ TEST(JSONWriterTest, BinaryValues) {
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   binary_list.Append(make_scoped_ptr(new FundamentalValue(2)));
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  EXPECT_FALSE(JSONWriter::Write(&binary_list, &output_js));
+  EXPECT_FALSE(JSONWriter::Write(binary_list, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
-      &binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
+      binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_EQ("[5,2]", output_js);
 
   DictionaryValue binary_dict;
@@ -143,9 +134,9 @@ TEST(JSONWriterTest, BinaryValues) {
   binary_dict.SetInteger("d", 2);
   binary_dict.Set(
       "e", make_scoped_ptr(BinaryValue::CreateWithCopiedBuffer("asdf", 4)));
-  EXPECT_FALSE(JSONWriter::Write(&binary_dict, &output_js));
+  EXPECT_FALSE(JSONWriter::Write(binary_dict, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
-      &binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
+      binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_EQ("{\"b\":5,\"d\":2}", output_js);
 }
 
@@ -155,8 +146,7 @@ TEST(JSONWriterTest, DoublesAsInts) {
   // Test allowing a double with no fractional part to be written as an integer.
   FundamentalValue double_value(1e10);
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
-      &double_value,
-      JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
+      double_value, JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &output_js));
   EXPECT_EQ("10000000000", output_js);
 }
diff --git a/base/trace_event/trace_event_argument.cc b/base/trace_event/trace_event_argument.cc
index 88b1879..e83aa73 100644
--- a/base/trace_event/trace_event_argument.cc
+++ b/base/trace_event/trace_event_argument.cc
@@ -108,7 +108,7 @@ ListValue* TracedValue::GetCurrentArray() {
 
 void TracedValue::AppendAsTraceFormat(std::string* out) const {
   std::string tmp;
-  JSONWriter::Write(stack_.front(), &tmp);
+  JSONWriter::Write(*stack_.front(), &tmp);
   *out += tmp;
   DCHECK_EQ(1u, stack_.size()) << tmp;
 }
diff --git a/base/trace_event/trace_event_system_stats_monitor.cc b/base/trace_event/trace_event_system_stats_monitor.cc
index 98f361a..c08d9b9 100644
--- a/base/trace_event/trace_event_system_stats_monitor.cc
+++ b/base/trace_event/trace_event_system_stats_monitor.cc
@@ -125,7 +125,7 @@ bool TraceEventSystemStatsMonitor::IsTimerRunningForTest() const {
 void AppendSystemProfileAsTraceFormat(const SystemMetrics& system_metrics,
                                       std::string* output) {
   std::string tmp;
-  base::JSONWriter::Write(system_metrics.ToValue().get(), &tmp);
+  base::JSONWriter::Write(*system_metrics.ToValue(), &tmp);
   *output += tmp;
 }
 
diff --git a/base/values.cc b/base/values.cc
index 4093eba..ebd7157 100644
--- a/base/values.cc
+++ b/base/values.cc
@@ -1168,9 +1168,7 @@ ValueDeserializer::~ValueDeserializer() {
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
-  JSONWriter::WriteWithOptions(&value,
-                               JSONWriter::OPTIONS_PRETTY_PRINT,
-                               &json);
+  JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return out << json;
 }
 
diff --git a/cc/debug/traced_picture.cc b/cc/debug/traced_picture.cc
index 2c7622b..3241871 100644
--- a/cc/debug/traced_picture.cc
+++ b/cc/debug/traced_picture.cc
@@ -40,18 +40,16 @@ void TracedPicture::AppendPictureAlias(std::string* out) const {
   scoped_ptr<base::DictionaryValue> alias(new base::DictionaryValue());
   alias->SetString("id_ref", base::StringPrintf("%p", picture_.get()));
 
-  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->Set("alias", alias.release());
-
+  base::DictionaryValue res;
+  res.Set("alias", alias.release());
   std::string tmp;
-  base::JSONWriter::Write(res.get(), &tmp);
+  base::JSONWriter::Write(res, &tmp);
   out->append(tmp);
 }
 
 void TracedPicture::AppendPicture(std::string* out) const {
-  scoped_ptr<base::Value> value = picture_->AsValue();
   std::string tmp;
-  base::JSONWriter::Write(value.get(), &tmp);
+  base::JSONWriter::Write(*picture_->AsValue(), &tmp);
   out->append(tmp);
 }
 
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index d5e6ad6..d421f84b 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -3124,7 +3124,7 @@ std::string LayerTreeHostImpl::LayerTreeAsJson() const {
   if (active_tree_->root_layer()) {
     scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
     base::JSONWriter::WriteWithOptions(
-        json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
+        *json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
   }
   return str;
 }
diff --git a/chrome/browser/caps/generate_state_json.cc b/chrome/browser/caps/generate_state_json.cc
index 3857d27..41a2a5d 100644
--- a/chrome/browser/caps/generate_state_json.cc
+++ b/chrome/browser/caps/generate_state_json.cc
@@ -90,7 +90,7 @@ class TaskManagerDataDumper :
 
     std::string json;
     auto options = base::JSONWriter::OPTIONS_PRETTY_PRINT;
-    if (!base::JSONWriter::WriteWithOptions(&dict, options, &json))
+    if (!base::JSONWriter::WriteWithOptions(dict, options, &json))
       return;
 
     file_.WriteAtCurrentPos(json.c_str(), json.size());
diff --git a/chrome/browser/chromeos/app_mode/kiosk_app_data.cc b/chrome/browser/chromeos/app_mode/kiosk_app_data.cc
index 5245aad..22d73d3 100644
--- a/chrome/browser/chromeos/app_mode/kiosk_app_data.cc
+++ b/chrome/browser/chromeos/app_mode/kiosk_app_data.cc
@@ -76,7 +76,7 @@ bool IsValidKioskAppManifest(const extensions::Manifest& manifest) {
   return false;
 }
 
-std::string ValueToString(const base::Value* value) {
+std::string ValueToString(const base::Value& value) {
   std::string json;
   base::JSONWriter::Write(value, &json);
   return json;
@@ -602,7 +602,7 @@ void KioskAppData::OnWebstoreResponseParseSuccess(
       icon_url_string);
   if (!icon_url.is_valid()) {
     LOG(ERROR) << "Webstore response error (icon url): "
-               << ValueToString(webstore_data.get());
+               << ValueToString(*webstore_data);
     OnWebstoreResponseParseFailure(kInvalidWebstoreResponseError);
     return;
   }
@@ -626,7 +626,7 @@ bool KioskAppData::CheckResponseKeyValue(const base::DictionaryValue* response,
                                          std::string* value) {
   if (!response->GetString(key, value)) {
     LOG(ERROR) << "Webstore response error (" << key
-               << "): " << ValueToString(response);
+               << "): " << ValueToString(*response);
     OnWebstoreResponseParseFailure(kInvalidWebstoreResponseError);
     return false;
   }
diff --git a/chrome/browser/chromeos/bluetooth/bluetooth_pairing_dialog.cc b/chrome/browser/chromeos/bluetooth/bluetooth_pairing_dialog.cc
index ff089f3..68712f2 100644
--- a/chrome/browser/chromeos/bluetooth/bluetooth_pairing_dialog.cc
+++ b/chrome/browser/chromeos/bluetooth/bluetooth_pairing_dialog.cc
@@ -76,7 +76,7 @@ void BluetoothPairingDialog::GetDialogSize(gfx::Size* size) const {
 
 std::string BluetoothPairingDialog::GetDialogArgs() const {
   std::string data;
-  base::JSONWriter::Write(&device_data_, &data);
+  base::JSONWriter::Write(device_data_, &data);
   return data;
 }
 
diff --git a/chrome/browser/chromeos/boot_times_recorder.cc b/chrome/browser/chromeos/boot_times_recorder.cc
index e9a3cec..268aef6 100644
--- a/chrome/browser/chromeos/boot_times_recorder.cc
+++ b/chrome/browser/chromeos/boot_times_recorder.cc
@@ -152,7 +152,7 @@ std::string BootTimesRecorder::Stats::SerializeToString() const {
   dictionary.SetString(kDisk, disk_);
 
   std::string result;
-  if (!base::JSONWriter::Write(&dictionary, &result)) {
+  if (!base::JSONWriter::Write(dictionary, &result)) {
     LOG(WARNING) << "BootTimesRecorder::Stats::SerializeToString(): failed.";
     return std::string();
   }
diff --git a/chrome/browser/chromeos/extensions/accessibility_features_apitest.cc b/chrome/browser/chromeos/extensions/accessibility_features_apitest.cc
index 8245a9e..25765814 100644
--- a/chrome/browser/chromeos/extensions/accessibility_features_apitest.cc
+++ b/chrome/browser/chromeos/extensions/accessibility_features_apitest.cc
@@ -158,7 +158,7 @@ class AccessibilityFeaturesApiTest : public ExtensionApiTest,
       disabled_list->AppendString(disabled_features[i]);
     test_arg.Set(kDisabledFeaturesKey, disabled_list.release());
 
-    return base::JSONWriter::Write(&test_arg, result);
+    return base::JSONWriter::Write(test_arg, result);
   }
 };
 
diff --git a/chrome/browser/chromeos/file_manager/file_manager_browsertest.cc b/chrome/browser/chromeos/file_manager/file_manager_browsertest.cc
index 1aa481f..f4aab53 100644
--- a/chrome/browser/chromeos/file_manager/file_manager_browsertest.cc
+++ b/chrome/browser/chromeos/file_manager/file_manager_browsertest.cc
@@ -681,13 +681,15 @@ void FileManagerBrowserTestBase::OnMessage(const std::string& name,
 
   if (name == "getRootPaths") {
     // Pass the root paths.
-    const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-    res->SetString("downloads",
-        "/" + util::GetDownloadsMountPointName(profile()));
-    res->SetString("drive",
-        "/" + drive::util::GetDriveMountPointPath(profile()
-            ).BaseName().AsUTF8Unsafe() + "/root");
-    base::JSONWriter::Write(res.get(), output);
+    base::DictionaryValue res;
+    res.SetString("downloads",
+                  "/" + util::GetDownloadsMountPointName(profile()));
+    res.SetString("drive", "/" +
+                               drive::util::GetDriveMountPointPath(profile())
+                                   .BaseName()
+                                   .AsUTF8Unsafe() +
+                               "/root");
+    base::JSONWriter::Write(res, output);
     return;
   }
 
@@ -707,10 +709,10 @@ void FileManagerBrowserTestBase::OnMessage(const std::string& name,
     if (*origin.rbegin() == '/')
       origin.resize(origin.length() - 1);
 
-    const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-    res->SetString("url", url.spec());
-    res->SetString("origin", origin);
-    base::JSONWriter::Write(res.get(), output);
+    base::DictionaryValue res;
+    res.SetString("url", url.spec());
+    res.SetString("origin", origin);
+    base::JSONWriter::Write(res, output);
     return;
   }
 
diff --git a/chrome/browser/chromeos/file_manager/url_util.cc b/chrome/browser/chromeos/file_manager/url_util.cc
index 088751b..1f3e9d8 100644
--- a/chrome/browser/chromeos/file_manager/url_util.cc
+++ b/chrome/browser/chromeos/file_manager/url_util.cc
@@ -111,7 +111,7 @@ GURL GetFileManagerMainPageUrlWithParams(
                        !file_types || !file_types->support_drive);
 
   std::string json_args;
-  base::JSONWriter::Write(&arg_value, &json_args);
+  base::JSONWriter::Write(arg_value, &json_args);
 
   std::string url = GetFileManagerMainPageUrl().spec() + '?' +
       net::EscapeUrlEncodedData(json_args,
diff --git a/chrome/browser/chromeos/file_manager/url_util_unittest.cc b/chrome/browser/chromeos/file_manager/url_util_unittest.cc
index 1360d00..569617d 100644
--- a/chrome/browser/chromeos/file_manager/url_util_unittest.cc
+++ b/chrome/browser/chromeos/file_manager/url_util_unittest.cc
@@ -23,9 +23,8 @@ std::string PrettyPrintEscapedJson(const std::string& query) {
       query, net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
   scoped_ptr<base::Value> value(base::JSONReader::Read(json));
   std::string pretty_json;
-  base::JSONWriter::WriteWithOptions(value.get(),
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &pretty_json);
+  base::JSONWriter::WriteWithOptions(
+      *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty_json);
   return pretty_json;
 }
 
diff --git a/chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.cc b/chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.cc
index b354238..63cab01 100644
--- a/chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.cc
+++ b/chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.cc
@@ -656,10 +656,12 @@ class UserImageManagerPolicyTest : public UserImageManagerTest,
       ADD_FAILURE();
     }
     std::string policy;
-    base::JSONWriter::Write(policy::test::ConstructExternalDataReference(
-        embedded_test_server()->GetURL(std::string("/") + relative_path).spec(),
-        image_data).get(),
-        &policy);
+    base::JSONWriter::Write(*policy::test::ConstructExternalDataReference(
+                                embedded_test_server()
+                                    ->GetURL(std::string("/") + relative_path)
+                                    .spec(),
+                                image_data),
+                            &policy);
     return policy;
   }
 
diff --git a/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_policy_browsertest.cc b/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_policy_browsertest.cc
index 576d9f3..8455a40 100644
--- a/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_policy_browsertest.cc
+++ b/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_policy_browsertest.cc
@@ -220,10 +220,12 @@ class WallpaperManagerPolicyTest
       ADD_FAILURE();
     }
     std::string policy;
-    base::JSONWriter::Write(policy::test::ConstructExternalDataReference(
-        embedded_test_server()->GetURL(std::string("/") + relative_path).spec(),
-        image_data).get(),
-        &policy);
+    base::JSONWriter::Write(*policy::test::ConstructExternalDataReference(
+                                embedded_test_server()
+                                    ->GetURL(std::string("/") + relative_path)
+                                    .spec(),
+                                image_data),
+                            &policy);
     return policy;
   }
 
diff --git a/chrome/browser/chromeos/net/onc_utils.cc b/chrome/browser/chromeos/net/onc_utils.cc
index abcd08a..2e4194eb 100644
--- a/chrome/browser/chromeos/net/onc_utils.cc
+++ b/chrome/browser/chromeos/net/onc_utils.cc
@@ -228,7 +228,7 @@ void ImportNetworksForUser(const user_manager::User* user,
     base::DictionaryValue ui_data_dict;
     ui_data->FillDictionary(&ui_data_dict);
     std::string ui_data_json;
-    base::JSONWriter::Write(&ui_data_dict, &ui_data_json);
+    base::JSONWriter::Write(ui_data_dict, &ui_data_json);
     shill_dict->SetStringWithoutPathExpansion(shill::kUIDataProperty,
                                               ui_data_json);
 
diff --git a/chrome/browser/chromeos/net/proxy_config_handler.cc b/chrome/browser/chromeos/net/proxy_config_handler.cc
index 4fa3d66..0351f34 100644
--- a/chrome/browser/chromeos/net/proxy_config_handler.cc
+++ b/chrome/browser/chromeos/net/proxy_config_handler.cc
@@ -112,7 +112,7 @@ void SetProxyConfigForNetwork(const ProxyConfigDictionary& proxy_config,
                    network_handler::ErrorCallback()));
   } else {
     std::string proxy_config_str;
-    base::JSONWriter::Write(&proxy_config.GetDictionary(), &proxy_config_str);
+    base::JSONWriter::Write(proxy_config.GetDictionary(), &proxy_config_str);
     shill_service_client->SetProperty(
         dbus::ObjectPath(network.path()),
         shill::kProxyConfigProperty,
diff --git a/chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc b/chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc
index 292507f..aa26956 100644
--- a/chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc
+++ b/chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc
@@ -82,8 +82,7 @@ void ConstructAvatarPolicy(const std::string& file_name,
       test_data_dir.Append("chromeos").Append(file_name),
       policy_data));
   base::JSONWriter::Write(
-      test::ConstructExternalDataReference(url, *policy_data).get(),
-      policy);
+      *test::ConstructExternalDataReference(url, *policy_data), policy);
 }
 
 }  // namespace
diff --git a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
index 6530914..f62b6c3 100644
--- a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
+++ b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
@@ -298,9 +298,8 @@ base::Value* NetworkConfigurationPolicyHandler::SanitizeNetworkConfig(
       *toplevel_dict,
       kPlaceholder);
 
-  base::JSONWriter::WriteWithOptions(toplevel_dict.get(),
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json_string);
+  base::JSONWriter::WriteWithOptions(
+      *toplevel_dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_string);
   return new base::StringValue(json_string);
 }
 
diff --git a/chrome/browser/chromeos/policy/device_local_account_browsertest.cc b/chrome/browser/chromeos/policy/device_local_account_browsertest.cc
index 108ac77..24509fc 100644
--- a/chrome/browser/chromeos/policy/device_local_account_browsertest.cc
+++ b/chrome/browser/chromeos/policy/device_local_account_browsertest.cc
@@ -1279,7 +1279,7 @@ IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExternalData) {
   scoped_ptr<base::DictionaryValue> metadata =
       test::ConstructExternalDataReference(kExternalDataURL, kExternalData);
   std::string policy;
-  base::JSONWriter::Write(metadata.get(), &policy);
+  base::JSONWriter::Write(*metadata, &policy);
   device_local_account_policy_.payload().mutable_useravatarimage()->set_value(
       policy);
   UploadAndInstallDeviceLocalAccountPolicy();
@@ -1362,10 +1362,13 @@ IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, UserAvatarImage) {
       &image_data));
 
   std::string policy;
-  base::JSONWriter::Write(test::ConstructExternalDataReference(
-      embedded_test_server()->GetURL(std::string("/") +
-          chromeos::test::kUserAvatarImage1RelativePath).spec(),
-      image_data).get(),
+  base::JSONWriter::Write(
+      *test::ConstructExternalDataReference(
+          embedded_test_server()
+              ->GetURL(std::string("/") +
+                       chromeos::test::kUserAvatarImage1RelativePath)
+              .spec(),
+          image_data),
       &policy);
   device_local_account_policy_.payload().mutable_useravatarimage()->set_value(
       policy);
diff --git a/chrome/browser/chromeos/policy/login_policy_test_base.cc b/chrome/browser/chromeos/policy/login_policy_test_base.cc
index 710b0bd..7fb6ada 100644
--- a/chrome/browser/chromeos/policy/login_policy_test_base.cc
+++ b/chrome/browser/chromeos/policy/login_policy_test_base.cc
@@ -54,10 +54,10 @@ std::string GetPolicy(scoped_ptr<base::DictionaryValue> mandatory,
   root_dict.SetString("policy_user", account);
   root_dict.SetInteger("current_key_index", 0);
 
-  std::string jsonPolicy;
+  std::string json_policy;
   base::JSONWriter::WriteWithOptions(
-      &root_dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &jsonPolicy);
-  return jsonPolicy;
+      root_dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_policy);
+  return json_policy;
 }
 
 }  // namespace
diff --git a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.cc b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.cc
index ccfd6c6..28deddf 100644
--- a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.cc
+++ b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.cc
@@ -81,8 +81,8 @@ class DeviceCommandScreenshotJob::Payload
 DeviceCommandScreenshotJob::Payload::Payload(ResultCode result_code) {
   base::DictionaryValue root_dict;
   if (result_code != SUCCESS)
-    root_dict.Set(kResultFieldName, new base::FundamentalValue(result_code));
-  base::JSONWriter::Write(&root_dict, &payload_);
+    root_dict.SetInteger(kResultFieldName, result_code);
+  base::JSONWriter::Write(root_dict, &payload_);
 }
 
 scoped_ptr<std::string> DeviceCommandScreenshotJob::Payload::Serialize() {
diff --git a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
index af7a240..8b07687 100644
--- a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
+++ b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
@@ -49,8 +49,8 @@ em::RemoteCommand GenerateScreenshotCommandProto(
   command_proto.set_age_of_command(age_of_command.InMilliseconds());
   std::string payload;
   base::DictionaryValue root_dict;
-  root_dict.Set(kUploadUrlFieldName, new base::StringValue(upload_url));
-  base::JSONWriter::Write(&root_dict, &payload);
+  root_dict.SetString(kUploadUrlFieldName, upload_url);
+  base::JSONWriter::Write(root_dict, &payload);
   command_proto.set_payload(payload);
   return command_proto;
 }
@@ -246,7 +246,7 @@ std::string DeviceCommandScreenshotTest::CreatePayloadFromResultCode(
   base::DictionaryValue root_dict;
   if (result_code != DeviceCommandScreenshotJob::SUCCESS)
     root_dict.Set(kResultFieldName, new base::FundamentalValue(result_code));
-  base::JSONWriter::Write(&root_dict, &payload);
+  base::JSONWriter::Write(root_dict, &payload);
   return payload;
 }
 
diff --git a/chrome/browser/chromeos/proxy_config_service_impl_unittest.cc b/chrome/browser/chromeos/proxy_config_service_impl_unittest.cc
index 785c48a..121ef02 100644
--- a/chrome/browser/chromeos/proxy_config_service_impl_unittest.cc
+++ b/chrome/browser/chromeos/proxy_config_service_impl_unittest.cc
@@ -333,7 +333,7 @@ class ProxyConfigServiceImplTest : public testing::Test {
   void SetUserConfigInShill(base::DictionaryValue* pref_proxy_config_dict) {
     std::string proxy_config;
     if (pref_proxy_config_dict)
-      base::JSONWriter::Write(pref_proxy_config_dict, &proxy_config);
+      base::JSONWriter::Write(*pref_proxy_config_dict, &proxy_config);
 
     NetworkStateHandler* network_state_handler =
         NetworkHandler::Get()->network_state_handler();
diff --git a/chrome/browser/component_updater/supervised_user_whitelist_installer_unittest.cc b/chrome/browser/component_updater/supervised_user_whitelist_installer_unittest.cc
index c6266a2..c5e897f 100644
--- a/chrome/browser/component_updater/supervised_user_whitelist_installer_unittest.cc
+++ b/chrome/browser/component_updater/supervised_user_whitelist_installer_unittest.cc
@@ -51,7 +51,7 @@ std::string CrxIdToHashToCrxId(const std::string& kCrxId) {
   return GetCrxComponentID(component);
 }
 
-std::string JsonToString(const base::DictionaryValue* dict) {
+std::string JsonToString(const base::DictionaryValue& dict) {
   std::string json;
   base::JSONWriter::Write(dict, &json);
   return json;
@@ -310,8 +310,8 @@ TEST_F(SupervisedUserWhitelistInstallerTest, InstallNewWhitelist) {
   ASSERT_TRUE(base::ReadFileToString(whitelist_path_, &whitelist_contents));
   EXPECT_EQ(kWhitelistContents, whitelist_contents);
 
-  EXPECT_EQ(JsonToString(&pref_),
-            JsonToString(local_state_.GetDictionary(
+  EXPECT_EQ(JsonToString(pref_),
+            JsonToString(*local_state_.GetDictionary(
                 prefs::kRegisteredSupervisedUserWhitelists)));
 }
 
diff --git a/chrome/browser/content_settings/host_content_settings_map_unittest.cc b/chrome/browser/content_settings/host_content_settings_map_unittest.cc
index 6247af2..0cf740f 100644
--- a/chrome/browser/content_settings/host_content_settings_map_unittest.cc
+++ b/chrome/browser/content_settings/host_content_settings_map_unittest.cc
@@ -720,8 +720,8 @@ TEST_F(HostContentSettingsMapTest, CanonicalizeExceptionsUnicodeAndPunycode) {
   // Initialize the content map.
   profile.GetHostContentSettingsMap();
 
-  const base::DictionaryValue* content_setting_prefs =
-      profile.GetPrefs()->GetDictionary(
+  const base::DictionaryValue& content_setting_prefs =
+      *profile.GetPrefs()->GetDictionary(
           prefs::kContentSettingsImagesPatternPairs);
   std::string prefs_as_json;
   base::JSONWriter::Write(content_setting_prefs, &prefs_as_json);
diff --git a/chrome/browser/devtools/device/webrtc/send_command_request.cc b/chrome/browser/devtools/device/webrtc/send_command_request.cc
index d09be25..7bfe5f4 100644
--- a/chrome/browser/devtools/device/webrtc/send_command_request.cc
+++ b/chrome/browser/devtools/device/webrtc/send_command_request.cc
@@ -22,7 +22,7 @@ const char kCommandTimeoutMs[] = "20000";
 SendCommandRequest::SendCommandRequest(const base::DictionaryValue* request,
                                        Delegate* delegate)
     : delegate_(delegate) {
-  base::JSONWriter::Write(request, &upload_data_);
+  base::JSONWriter::Write(*request, &upload_data_);
   DCHECK(delegate_);
 }
 
diff --git a/chrome/browser/devtools/devtools_protocol.cc b/chrome/browser/devtools/devtools_protocol.cc
index 8df0557..5687220 100644
--- a/chrome/browser/devtools/devtools_protocol.cc
+++ b/chrome/browser/devtools/devtools_protocol.cc
@@ -37,7 +37,7 @@ std::string DevToolsProtocol::SerializeCommand(
     command.Set(kParamsParam, params.release());
 
   std::string json_command;
-  base::JSONWriter::Write(&command, &json_command);
+  base::JSONWriter::Write(command, &json_command);
   return json_command;
 }
 
diff --git a/chrome/browser/devtools/devtools_ui_bindings.cc b/chrome/browser/devtools/devtools_ui_bindings.cc
index 3a5d3ca..69ab19f 100644
--- a/chrome/browser/devtools/devtools_ui_bindings.cc
+++ b/chrome/browser/devtools/devtools_ui_bindings.cc
@@ -1016,13 +1016,13 @@ void DevToolsUIBindings::CallClientFunction(const std::string& function_name,
   std::string javascript = function_name + "(";
   if (arg1) {
     std::string json;
-    base::JSONWriter::Write(arg1, &json);
+    base::JSONWriter::Write(*arg1, &json);
     javascript.append(json);
     if (arg2) {
-      base::JSONWriter::Write(arg2, &json);
+      base::JSONWriter::Write(*arg2, &json);
       javascript.append(", ").append(json);
       if (arg3) {
-        base::JSONWriter::Write(arg3, &json);
+        base::JSONWriter::Write(*arg3, &json);
         javascript.append(", ").append(json);
       }
     }
diff --git a/chrome/browser/extensions/api/debugger/debugger_api.cc b/chrome/browser/extensions/api/debugger/debugger_api.cc
index 14638ef..27623d9 100644
--- a/chrome/browser/extensions/api/debugger/debugger_api.cc
+++ b/chrome/browser/extensions/api/debugger/debugger_api.cc
@@ -385,7 +385,7 @@ void ExtensionDevToolsClientHost::SendMessageToBackend(
   }
 
   std::string json_args;
-  base::JSONWriter::Write(&protocol_request, &json_args);
+  base::JSONWriter::Write(protocol_request, &json_args);
   agent_host_->DispatchProtocolMessage(json_args);
 }
 
@@ -666,7 +666,7 @@ void DebuggerSendCommandFunction::SendResponseBody(
     base::DictionaryValue* response) {
   base::Value* error_body;
   if (response->Get("error", &error_body)) {
-    base::JSONWriter::Write(error_body, &error_);
+    base::JSONWriter::Write(*error_body, &error_);
     SendResponse(false);
     return;
   }
diff --git a/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc b/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
index 3b7d50d..65e3aec 100644
--- a/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
+++ b/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
@@ -146,15 +146,15 @@ class ExtensionInfoGeneratorUnitTest : public ExtensionServiceTestBase {
     std::string actual_string;
     for (base::DictionaryValue::Iterator field(*expected_output_data);
          !field.IsAtEnd(); field.Advance()) {
-      const base::Value* expected_value = &field.value();
+      const base::Value& expected_value = field.value();
       base::Value* actual_value = nullptr;
       EXPECT_TRUE(actual_output_data->Get(field.key(), &actual_value)) <<
           field.key() + " is missing" + paths_details;
       if (!actual_value)
         continue;
-      if (!actual_value->Equals(expected_value)) {
+      if (!actual_value->Equals(&expected_value)) {
         base::JSONWriter::Write(expected_value, &expected_string);
-        base::JSONWriter::Write(actual_value, &actual_string);
+        base::JSONWriter::Write(*actual_value, &actual_string);
         EXPECT_EQ(expected_string, actual_string) <<
             field.key() << paths_details;
       }
diff --git a/chrome/browser/extensions/api/downloads/downloads_api.cc b/chrome/browser/extensions/api/downloads/downloads_api.cc
index 268043e..0d614aa 100644
--- a/chrome/browser/extensions/api/downloads/downloads_api.cc
+++ b/chrome/browser/extensions/api/downloads/downloads_api.cc
@@ -1860,7 +1860,7 @@ void ExtensionDownloadsEventRouter::DispatchEvent(
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
-  base::JSONWriter::Write(args.get(), &json_args);
+  base::JSONWriter::Write(*args, &json_args);
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
   // The downloads system wants to share on-record events with off-record
   // extension renderers even in incognito_split_mode because that's how
diff --git a/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc b/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
index 1cffad6..67740e1 100644
--- a/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
+++ b/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
@@ -164,7 +164,7 @@ class MediaGalleriesPlatformAppBrowserTest : public PlatformAppBrowserTest {
     const char* custom_arg = NULL;
     std::string json_string;
     if (!custom_arg_value.empty()) {
-      base::JSONWriter::Write(&custom_arg_value, &json_string);
+      base::JSONWriter::Write(custom_arg_value, &json_string);
       custom_arg = json_string.c_str();
     }
 
diff --git a/chrome/browser/extensions/api/messaging/message_property_provider.cc b/chrome/browser/extensions/api/messaging/message_property_provider.cc
index cee56d7..a1eb7acf 100644
--- a/chrome/browser/extensions/api/messaging/message_property_provider.cc
+++ b/chrome/browser/extensions/api/messaging/message_property_provider.cc
@@ -100,7 +100,7 @@ void MessagePropertyProvider::GotChannelID(
     return;
   }
   std::string jwk_str;
-  base::JSONWriter::Write(&jwk_value, &jwk_str);
+  base::JSONWriter::Write(jwk_value, &jwk_str);
   original_task_runner->PostTask(FROM_HERE, base::Bind(reply, jwk_str));
 }
 
diff --git a/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc b/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
index 4977908..0fbc770 100644
--- a/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
+++ b/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
@@ -70,12 +70,12 @@ class EchoHost : public NativeMessageHost {
 
  private:
   void ProcessEcho(const base::DictionaryValue& request) {
-    scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
-    response->SetInteger("id", ++message_number_);
-    response->Set("echo", request.DeepCopy());
-    response->SetString("caller_url", kEchoHostOrigins[0]);
+    base::DictionaryValue response;
+    response.SetInteger("id", ++message_number_);
+    response.Set("echo", request.CreateDeepCopy());
+    response.SetString("caller_url", kEchoHostOrigins[0]);
     std::string response_string;
-    base::JSONWriter::Write(response.get(), &response_string);
+    base::JSONWriter::Write(response, &response_string);
     client_->PostMessageFromNativeHost(response_string);
   }
 
diff --git a/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc b/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
index 19aa3e1..13ce9b1 100644
--- a/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
+++ b/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
@@ -51,7 +51,7 @@ scoped_ptr<Permissions> PackPermissionSet(const PermissionSet* set) {
     } else {
       std::string name(i->name());
       std::string json;
-      base::JSONWriter::Write(value.get(), &json);
+      base::JSONWriter::Write(*value, &json);
       permissions->permissions->push_back(name + kDelimiter + json);
     }
   }
diff --git a/chrome/browser/extensions/api/storage/settings_apitest.cc b/chrome/browser/extensions/api/storage/settings_apitest.cc
index eaa5ea1..50f0383 100644
--- a/chrome/browser/extensions/api/storage/settings_apitest.cc
+++ b/chrome/browser/extensions/api/storage/settings_apitest.cc
@@ -174,12 +174,12 @@ class ExtensionSettingsApiTest : public ExtensionApiTest {
       Namespace settings_namespace,
       const std::string& action,
       bool is_final_action) {
-    scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
-    message->SetString("namespace", ToString(settings_namespace));
-    message->SetString("action", action);
-    message->SetBoolean("isFinalAction", is_final_action);
+    base::DictionaryValue message;
+    message.SetString("namespace", ToString(settings_namespace));
+    message.SetString("action", action);
+    message.SetBoolean("isFinalAction", is_final_action);
     std::string message_json;
-    base::JSONWriter::Write(message.get(), &message_json);
+    base::JSONWriter::Write(message, &message_json);
     return message_json;
   }
 
diff --git a/chrome/browser/extensions/api/storage/settings_sync_unittest.cc b/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
index 9ed1922..ab4f521 100644
--- a/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
+++ b/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
@@ -45,9 +45,8 @@ const ValueStore::WriteOptions DEFAULTS = ValueStore::DEFAULTS;
 // Gets the pretty-printed JSON for a value.
 static std::string GetJson(const base::Value& value) {
   std::string json;
-  base::JSONWriter::WriteWithOptions(&value,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
+  base::JSONWriter::WriteWithOptions(
+      value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/chrome/browser/extensions/api/storage/settings_sync_util.cc b/chrome/browser/extensions/api/storage/settings_sync_util.cc
index c187c52..ccd9a44 100644
--- a/chrome/browser/extensions/api/storage/settings_sync_util.cc
+++ b/chrome/browser/extensions/api/storage/settings_sync_util.cc
@@ -30,7 +30,7 @@ void PopulateExtensionSettingSpecifics(
   specifics->set_key(key);
   {
     std::string value_as_json;
-    base::JSONWriter::Write(&value, &value_as_json);
+    base::JSONWriter::Write(value, &value_as_json);
     specifics->set_value(value_as_json);
   }
 }
diff --git a/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc b/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
index 95bcf2e..289aeec 100644
--- a/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
+++ b/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
@@ -94,7 +94,7 @@ class WebrtcAudioPrivateTest : public AudioWaitingExtensionTest {
     base::ListValue parameters;
     AppendTabIdToRequestInfo(&parameters, tab_id);
     std::string parameter_string;
-    JSONWriter::Write(&parameters, &parameter_string);
+    JSONWriter::Write(parameters, &parameter_string);
 
     scoped_refptr<WebrtcAudioPrivateGetActiveSinkFunction> function =
         new WebrtcAudioPrivateGetActiveSinkFunction();
@@ -180,7 +180,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetSinks) {
   scoped_ptr<base::Value> result = InvokeGetSinks(&sink_list);
 
   std::string result_string;
-  JSONWriter::Write(result.get(), &result_string);
+  JSONWriter::Write(*result, &result_string);
   VLOG(2) << result_string;
 
   EXPECT_EQ(devices.size(), sink_list->GetSize());
@@ -229,7 +229,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetActiveSinkNoMediaStream) {
   base::ListValue parameters;
   AppendTabIdToRequestInfo(&parameters, tab_id);
   std::string parameter_string;
-  JSONWriter::Write(&parameters, &parameter_string);
+  JSONWriter::Write(parameters, &parameter_string);
 
   scoped_refptr<WebrtcAudioPrivateGetActiveSinkFunction> function =
       new WebrtcAudioPrivateGetActiveSinkFunction();
@@ -240,7 +240,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetActiveSinkNoMediaStream) {
                                        browser()));
 
   std::string result_string;
-  JSONWriter::Write(result.get(), &result_string);
+  JSONWriter::Write(*result, &result_string);
   EXPECT_EQ("\"\"", result_string);
 }
 
@@ -253,7 +253,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, SetActiveSinkNoMediaStream) {
   AppendTabIdToRequestInfo(&parameters, tab_id);
   parameters.AppendString("no such id");
   std::string parameter_string;
-  JSONWriter::Write(&parameters, &parameter_string);
+  JSONWriter::Write(parameters, &parameter_string);
 
   scoped_refptr<WebrtcAudioPrivateSetActiveSinkFunction> function =
       new WebrtcAudioPrivateSetActiveSinkFunction();
@@ -299,7 +299,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetAndSetWithMediaStream) {
     AppendTabIdToRequestInfo(&parameters, tab_id);
     parameters.AppendString(target_device);
     std::string parameter_string;
-    JSONWriter::Write(&parameters, &parameter_string);
+    JSONWriter::Write(parameters, &parameter_string);
 
     scoped_refptr<WebrtcAudioPrivateSetActiveSinkFunction> function =
       new WebrtcAudioPrivateSetActiveSinkFunction();
@@ -345,14 +345,14 @@ IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetAssociatedSink) {
     parameters.AppendString(origin.spec());
     parameters.AppendString(source_id_in_origin);
     std::string parameter_string;
-    JSONWriter::Write(&parameters, &parameter_string);
+    JSONWriter::Write(parameters, &parameter_string);
 
     scoped_ptr<base::Value> result(
         RunFunctionAndReturnSingleResult(function.get(),
                                          parameter_string,
                                          browser()));
     std::string result_string;
-    JSONWriter::Write(result.get(), &result_string);
+    JSONWriter::Write(*result, &result_string);
     VLOG(2) << "Results: " << result_string;
   }
 }
diff --git a/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_apitest.cc b/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_apitest.cc
index fc80b08..cb5ab5e9 100644
--- a/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_apitest.cc
+++ b/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_apitest.cc
@@ -35,7 +35,7 @@ static const char kTestLoggingUrl[] = "dummy url string";
 
 std::string ParamsToString(const base::ListValue& parameters) {
   std::string parameter_string;
-  EXPECT_TRUE(base::JSONWriter::Write(&parameters, &parameter_string));
+  EXPECT_TRUE(base::JSONWriter::Write(parameters, &parameter_string));
   return parameter_string;
 }
 
diff --git a/chrome/browser/extensions/extension_messages_apitest.cc b/chrome/browser/extensions/extension_messages_apitest.cc
index 1c43052..9edda30 100644
--- a/chrome/browser/extensions/extension_messages_apitest.cc
+++ b/chrome/browser/extensions/extension_messages_apitest.cc
@@ -994,7 +994,7 @@ class ExternallyConnectableMessagingWithTlsChannelIdTest :
     base::DictionaryValue jwk_value;
     net::JwkSerializer::ConvertSpkiFromDerToJwk(spki, &jwk_value);
     std::string tls_channel_id_value;
-    base::JSONWriter::Write(&jwk_value, &tls_channel_id_value);
+    base::JSONWriter::Write(jwk_value, &tls_channel_id_value);
     return tls_channel_id_value;
   }
 
diff --git a/chrome/browser/extensions/install_signer.cc b/chrome/browser/extensions/install_signer.cc
index 1fca16a..afb88cc 100644
--- a/chrome/browser/extensions/install_signer.cc
+++ b/chrome/browser/extensions/install_signer.cc
@@ -388,7 +388,7 @@ void InstallSigner::GetSignature(const SignatureCallback& callback) {
   }
   dictionary.Set(kIdsKey, id_list.release());
   std::string json;
-  base::JSONWriter::Write(&dictionary, &json);
+  base::JSONWriter::Write(dictionary, &json);
   if (json.empty()) {
     ReportErrorViaCallback();
     return;
diff --git a/chrome/browser/extensions/test_extension_environment.cc b/chrome/browser/extensions/test_extension_environment.cc
index f8478fc..6914ab0 100644
--- a/chrome/browser/extensions/test_extension_environment.cc
+++ b/chrome/browser/extensions/test_extension_environment.cc
@@ -41,7 +41,7 @@ scoped_ptr<base::DictionaryValue> MakeExtensionManifest(
     manifest->MergeDictionary(manifest_extra_dict);
   } else {
     std::string manifest_json;
-    base::JSONWriter::Write(&manifest_extra, &manifest_json);
+    base::JSONWriter::Write(manifest_extra, &manifest_json);
     ADD_FAILURE() << "Expected dictionary; got \"" << manifest_json << "\"";
   }
   return manifest;
diff --git a/chrome/browser/local_discovery/privet_http_unittest.cc b/chrome/browser/local_discovery/privet_http_unittest.cc
index f8d5dbe..9fe8500d 100644
--- a/chrome/browser/local_discovery/privet_http_unittest.cc
+++ b/chrome/browser/local_discovery/privet_http_unittest.cc
@@ -222,7 +222,7 @@ std::string NormalizeJson(const std::string& json) {
   std::string result = json;
   scoped_ptr<base::Value> value(base::JSONReader::Read(result));
   DCHECK(value);
-  base::JSONWriter::Write(value.get(), &result);
+  base::JSONWriter::Write(*value, &result);
   return result;
 }
 
diff --git a/chrome/browser/local_discovery/privetv3_session.cc b/chrome/browser/local_discovery/privetv3_session.cc
index 85a9a42..b278279 100644
--- a/chrome/browser/local_discovery/privetv3_session.cc
+++ b/chrome/browser/local_discovery/privetv3_session.cc
@@ -410,7 +410,7 @@ void PrivetV3Session::StartPostRequest(const std::string& api,
     on_post_data_.Run(input);
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      &input, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      input, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   PrivetURLFetcher* fetcher =
       CreateFetcher(api, net::URLFetcher::RequestType::POST, callback);
   fetcher->SetUploadData(cloud_print::kContentTypeJSON, json);
diff --git a/chrome/browser/policy/test/local_policy_test_server.cc b/chrome/browser/policy/test/local_policy_test_server.cc
index d4bb6c7..439067f 100644
--- a/chrome/browser/policy/test/local_policy_test_server.cc
+++ b/chrome/browser/policy/test/local_policy_test_server.cc
@@ -240,7 +240,7 @@ bool LocalPolicyTestServer::GenerateAdditionalArguments(
 
     if (!clients_.empty()) {
       std::string json;
-      base::JSONWriter::Write(&clients_, &json);
+      base::JSONWriter::Write(clients_, &json);
       base::FilePath client_state_file =
           server_data_dir_.path().Append(kClientStateFileName);
       if (base::WriteFile(client_state_file, json.c_str(), json.size()) !=
diff --git a/chrome/browser/profile_resetter/resettable_settings_snapshot.cc b/chrome/browser/profile_resetter/resettable_settings_snapshot.cc
index d7d0001..da82550 100644
--- a/chrome/browser/profile_resetter/resettable_settings_snapshot.cc
+++ b/chrome/browser/profile_resetter/resettable_settings_snapshot.cc
@@ -215,7 +215,7 @@ std::string SerializeSettingsReport(const ResettableSettingsSnapshot& snapshot,
                 "new field needs to be serialized here");
 
   std::string json;
-  base::JSONWriter::Write(&dict, &json);
+  base::JSONWriter::Write(dict, &json);
   return json;
 }
 
diff --git a/chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.cc b/chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.cc
index 6ac435d..60b460a 100644
--- a/chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.cc
+++ b/chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.cc
@@ -62,7 +62,7 @@ void PreferenceValidationDelegate::OnAtomicPreferenceValidation(
     incident->set_path(pref_path);
     if (!value ||
         (!value->GetAsString(incident->mutable_atomic_value()) &&
-         !base::JSONWriter::Write(value, incident->mutable_atomic_value()))) {
+         !base::JSONWriter::Write(*value, incident->mutable_atomic_value()))) {
       incident->clear_atomic_value();
     }
     incident->set_value_state(proto_value_state);
diff --git a/chrome/browser/safe_json_parser_browsertest.cc b/chrome/browser/safe_json_parser_browsertest.cc
index 5d7f5a1..f67e513 100644
--- a/chrome/browser/safe_json_parser_browsertest.cc
+++ b/chrome/browser/safe_json_parser_browsertest.cc
@@ -19,7 +19,7 @@ std::string MaybeToJson(const base::Value* value) {
     return "(null)";
 
   std::string json;
-  if (!base::JSONWriter::Write(value, &json))
+  if (!base::JSONWriter::Write(*value, &json))
     return "(invalid value)";
 
   return json;
diff --git a/chrome/browser/speech/extension_api/tts_engine_extension_api.cc b/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
index bc050e1..7e4071f 100644
--- a/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
+++ b/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
@@ -191,7 +191,7 @@ void TtsExtensionEngine::Speak(Utterance* utterance,
   args->AppendInteger(utterance->id());
 
   std::string json;
-  base::JSONWriter::Write(args.get(), &json);
+  base::JSONWriter::Write(*args, &json);
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       tts_engine_events::kOnSpeak, args.Pass()));
diff --git a/chrome/browser/spellchecker/feedback_sender.cc b/chrome/browser/spellchecker/feedback_sender.cc
index 5ed97bb..bce2b81 100644
--- a/chrome/browser/spellchecker/feedback_sender.cc
+++ b/chrome/browser/spellchecker/feedback_sender.cc
@@ -403,7 +403,7 @@ void FeedbackSender::SendFeedback(const std::vector<Misspelling>& feedback_data,
                   country_),
       api_version_));
   std::string feedback;
-  base::JSONWriter::Write(feedback_value.get(), &feedback);
+  base::JSONWriter::Write(*feedback_value, &feedback);
 
   // The tests use this identifier to mock the URL fetcher.
   static const int kUrlFetcherId = 0;
diff --git a/chrome/browser/supervised_user/child_accounts/family_info_fetcher_unittest.cc b/chrome/browser/supervised_user/child_accounts/family_info_fetcher_unittest.cc
index 47f7af4..b855b7d 100644
--- a/chrome/browser/supervised_user/child_accounts/family_info_fetcher_unittest.cc
+++ b/chrome/browser/supervised_user/child_accounts/family_info_fetcher_unittest.cc
@@ -49,7 +49,7 @@ std::string BuildGetFamilyProfileResponse(
   family_dict->SetWithoutPathExpansion("profile", profile_dict);
   dict.SetWithoutPathExpansion("family", family_dict);
   std::string result;
-  base::JSONWriter::Write(&dict, &result);
+  base::JSONWriter::Write(dict, &result);
   return result;
 }
 
@@ -58,7 +58,7 @@ std::string BuildEmptyGetFamilyProfileResponse() {
   base::DictionaryValue* family_dict = new base::DictionaryValue;
   dict.SetWithoutPathExpansion("family", family_dict);
   std::string result;
-  base::JSONWriter::Write(&dict, &result);
+  base::JSONWriter::Write(dict, &result);
   return result;
 }
 
@@ -97,7 +97,7 @@ std::string BuildGetFamilyMembersResponse(
   }
   dict.SetWithoutPathExpansion("members", list);
   std::string result;
-  base::JSONWriter::Write(&dict, &result);
+  base::JSONWriter::Write(dict, &result);
   return result;
 }
 
diff --git a/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.cc b/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.cc
index 0f868f4..e14bbff 100644
--- a/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.cc
+++ b/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.cc
@@ -190,7 +190,7 @@ void PermissionRequestCreatorApiary::OnGetTokenSuccess(
   dict.SetStringWithoutPathExpansion(kStateKey, kState);
 
   std::string body;
-  base::JSONWriter::Write(&dict, &body);
+  base::JSONWriter::Write(dict, &body);
   (*it)->url_fetcher->SetUploadData("application/json", body);
 
   (*it)->url_fetcher->Start();
diff --git a/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary_unittest.cc b/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary_unittest.cc
index f78e9af..b092611 100644
--- a/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary_unittest.cc
+++ b/chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary_unittest.cc
@@ -24,7 +24,7 @@ std::string BuildResponse() {
   permission_dict->SetStringWithoutPathExpansion("id", "requestid");
   dict.SetWithoutPathExpansion("permissionRequest", permission_dict);
   std::string result;
-  base::JSONWriter::Write(&dict, &result);
+  base::JSONWriter::Write(dict, &result);
   return result;
 }
 
diff --git a/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker_unittest.cc b/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker_unittest.cc
index 0099af6..bc3dfd1 100644
--- a/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker_unittest.cc
+++ b/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker_unittest.cc
@@ -53,7 +53,7 @@ std::string BuildResponse(const GURL& url) {
     dict.SetWithoutPathExpansion("items", results_list);
   }
   std::string result;
-  base::JSONWriter::Write(&dict, &result);
+  base::JSONWriter::Write(dict, &result);
   return result;
 }
 
diff --git a/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.cc b/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.cc
index 94480d8..17fc6758 100644
--- a/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.cc
+++ b/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.cc
@@ -174,7 +174,7 @@ SyncData SupervisedUserSharedSettingsService::CreateSyncDataForSetting(
     const Value& value,
     bool acknowledged) {
   std::string json_value;
-  base::JSONWriter::Write(&value, &json_value);
+  base::JSONWriter::Write(value, &json_value);
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user_shared_setting()->set_mu_id(su_id);
   specifics.mutable_managed_user_shared_setting()->set_key(key);
diff --git a/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_unittest.cc b/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_unittest.cc
index eed022a..ffa3940 100644
--- a/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_unittest.cc
+++ b/chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_unittest.cc
@@ -69,7 +69,7 @@ std::string ToJson(const Value* value) {
     return std::string();
 
   std::string json_value;
-  base::JSONWriter::Write(value, &json_value);
+  base::JSONWriter::Write(*value, &json_value);
   return json_value;
 }
 
diff --git a/chrome/browser/supervised_user/supervised_user_settings_service.cc b/chrome/browser/supervised_user/supervised_user_settings_service.cc
index 421a2b4..41b4aa2 100644
--- a/chrome/browser/supervised_user/supervised_user_settings_service.cc
+++ b/chrome/browser/supervised_user/supervised_user_settings_service.cc
@@ -163,7 +163,7 @@ SyncData SupervisedUserSettingsService::CreateSyncDataForSetting(
     const std::string& name,
     const base::Value& value) {
   std::string json_value;
-  base::JSONWriter::Write(&value, &json_value);
+  base::JSONWriter::Write(value, &json_value);
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user_setting()->set_name(name);
   specifics.mutable_managed_user_setting()->set_value(json_value);
diff --git a/chrome/browser/sync/profile_sync_service_android.cc b/chrome/browser/sync/profile_sync_service_android.cc
index 59d44f7..d8e536e 100644
--- a/chrome/browser/sync/profile_sync_service_android.cc
+++ b/chrome/browser/sync/profile_sync_service_android.cc
@@ -441,7 +441,7 @@ ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::GetAboutInfoForTest(
   scoped_ptr<base::DictionaryValue> about_info =
       sync_ui_util::ConstructAboutInformation(sync_service_);
   std::string about_info_json;
-  base::JSONWriter::Write(about_info.get(), &about_info_json);
+  base::JSONWriter::Write(*about_info, &about_info_json);
 
   return ConvertUTF8ToJavaString(env, about_info_json);
 }
diff --git a/chrome/browser/sync/test/integration/extension_settings_helper.cc b/chrome/browser/sync/test/integration/extension_settings_helper.cc
index 73a8853..e9414af 100644
--- a/chrome/browser/sync/test/integration/extension_settings_helper.cc
+++ b/chrome/browser/sync/test/integration/extension_settings_helper.cc
@@ -31,9 +31,8 @@ namespace {
 
 std::string ToJson(const base::Value& value) {
   std::string json;
-  base::JSONWriter::WriteWithOptions(&value,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
+  base::JSONWriter::WriteWithOptions(
+      value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/chrome/browser/sync/test/integration/profile_sync_service_harness.cc b/chrome/browser/sync/test/integration/profile_sync_service_harness.cc
index bb71e35..fca7be5 100644
--- a/chrome/browser/sync/test/integration/profile_sync_service_harness.cc
+++ b/chrome/browser/sync/test/integration/profile_sync_service_harness.cc
@@ -469,8 +469,7 @@ std::string ProfileSyncServiceHarness::GetServiceStatus() {
   scoped_ptr<base::DictionaryValue> value(
       sync_ui_util::ConstructAboutInformation(service()));
   std::string service_status;
-  base::JSONWriter::WriteWithOptions(value.get(),
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &service_status);
+  base::JSONWriter::WriteWithOptions(
+      *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &service_status);
   return service_status;
 }
diff --git a/chrome/browser/task_profiler/task_profiler_data_serializer_unittest.cc b/chrome/browser/task_profiler/task_profiler_data_serializer_unittest.cc
index da040b7..5567eec 100644
--- a/chrome/browser/task_profiler/task_profiler_data_serializer_unittest.cc
+++ b/chrome/browser/task_profiler/task_profiler_data_serializer_unittest.cc
@@ -26,7 +26,7 @@ void ExpectSerialization(
       process_data_phase, process_id, process_type, &serialized_value);
 
   std::string serialized_json;
-  base::JSONWriter::Write(&serialized_value, &serialized_json);
+  base::JSONWriter::Write(serialized_value, &serialized_json);
 
   EXPECT_EQ(expected_json, serialized_json);
 }
diff --git a/chrome/browser/ui/webui/certificate_viewer_webui.cc b/chrome/browser/ui/webui/certificate_viewer_webui.cc
index 8bbbfdc..7f9c668 100644
--- a/chrome/browser/ui/webui/certificate_viewer_webui.cc
+++ b/chrome/browser/ui/webui/certificate_viewer_webui.cc
@@ -187,7 +187,7 @@ std::string CertificateViewerModalDialog::GetDialogArgs() const {
   // Set the last node as the top of the certificate hierarchy.
   cert_info.Set("hierarchy", children);
 
-  base::JSONWriter::Write(&cert_info, &data);
+  base::JSONWriter::Write(cert_info, &data);
 
   return data;
 }
diff --git a/chrome/browser/ui/webui/options/preferences_browsertest.cc b/chrome/browser/ui/webui/options/preferences_browsertest.cc
index 4a6511e..99805dc 100644
--- a/chrome/browser/ui/webui/options/preferences_browsertest.cc
+++ b/chrome/browser/ui/webui/options/preferences_browsertest.cc
@@ -68,7 +68,7 @@ bool operator==(const base::Value& first, const base::Value& second) {
 // Helper for pretty-printing the contents of base::Value in case of failures.
 void PrintTo(const base::Value& value, std::ostream* stream) {
   std::string json;
-  JSONWriter::Write(&value, &json);
+  JSONWriter::Write(value, &json);
   *stream << json;
 }
 
@@ -192,7 +192,7 @@ void PreferencesBrowserTest::SetUpInProcessBrowserTestFixture() {
       .WillRepeatedly(Return(true));
   policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
       &policy_provider_);
-};
+}
 
 void PreferencesBrowserTest::SetUserPolicies(
     const std::vector<std::string>& names,
@@ -376,9 +376,8 @@ void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
-  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::string commit_json;
-  base::JSONWriter::Write(commit_ptr.get(), &commit_json);
+  base::JSONWriter::Write(base::FundamentalValue(commit), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.clearPref("
diff --git a/chrome/browser/ui/webui/options/sync_setup_handler_unittest.cc b/chrome/browser/ui/webui/options/sync_setup_handler_unittest.cc
index ef6108e..a0c5de4 100644
--- a/chrome/browser/ui/webui/options/sync_setup_handler_unittest.cc
+++ b/chrome/browser/ui/webui/options/sync_setup_handler_unittest.cc
@@ -93,7 +93,7 @@ std::string GetConfiguration(const base::DictionaryValue* extra_values,
   result.SetBoolean("wifiCredentialsSynced",
                     types.Has(syncer::WIFI_CREDENTIALS));
   std::string args;
-  base::JSONWriter::Write(&result, &args);
+  base::JSONWriter::Write(result, &args);
   return args;
 }
 
diff --git a/chrome/browser/ui/webui/policy_ui.cc b/chrome/browser/ui/webui/policy_ui.cc
index 32aa620..03d4348 100644
--- a/chrome/browser/ui/webui/policy_ui.cc
+++ b/chrome/browser/ui/webui/policy_ui.cc
@@ -217,7 +217,7 @@ void ExtractDomainFromUsername(base::DictionaryValue* dict) {
 
 // Utility function that returns a JSON serialization of the given |dict|.
 scoped_ptr<base::StringValue> DictionaryToJSONString(
-    const base::DictionaryValue* dict) {
+    const base::DictionaryValue& dict) {
   std::string json_string;
   base::JSONWriter::WriteWithOptions(dict,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
@@ -230,14 +230,14 @@ scoped_ptr<base::StringValue> DictionaryToJSONString(
 scoped_ptr<base::Value> CopyAndConvert(const base::Value* value) {
   const base::DictionaryValue* dict = NULL;
   if (value->GetAsDictionary(&dict))
-    return DictionaryToJSONString(dict);
+    return DictionaryToJSONString(*dict);
 
   scoped_ptr<base::Value> copy(value->DeepCopy());
   base::ListValue* list = NULL;
   if (copy->GetAsList(&list)) {
     for (size_t i = 0; i < list->GetSize(); ++i) {
       if (list->GetDictionary(i, &dict))
-        list->Set(i, DictionaryToJSONString(dict).release());
+        list->Set(i, DictionaryToJSONString(*dict).release());
     }
   }
 
diff --git a/chrome/browser/ui/webui/signin/profile_signin_confirmation_dialog.cc b/chrome/browser/ui/webui/signin/profile_signin_confirmation_dialog.cc
index 1c688bb..5ad9d87 100644
--- a/chrome/browser/ui/webui/signin/profile_signin_confirmation_dialog.cc
+++ b/chrome/browser/ui/webui/signin/profile_signin_confirmation_dialog.cc
@@ -173,7 +173,7 @@ std::string ProfileSigninConfirmationDialog::GetDialogArgs() const {
 #if defined(OS_WIN)
   dict.SetBoolean("hideTitle", true);
 #endif
-  base::JSONWriter::Write(&dict, &data);
+  base::JSONWriter::Write(dict, &data);
   return data;
 }
 
diff --git a/chrome/renderer/net/net_error_helper.cc b/chrome/renderer/net/net_error_helper.cc
index 00c2964..a3ab4e5 100644
--- a/chrome/renderer/net/net_error_helper.cc
+++ b/chrome/renderer/net/net_error_helper.cc
@@ -230,7 +230,7 @@ void NetErrorHelper::UpdateErrorPage(const blink::WebURLError& error,
                              &error_strings);
 
   std::string json;
-  JSONWriter::Write(&error_strings, &json);
+  JSONWriter::Write(error_strings, &json);
 
   std::string js = "if (window.updateForDnsProbe) "
                    "updateForDnsProbe(" + json + ");";
diff --git a/chrome/service/cloud_print/print_system_win.cc b/chrome/service/cloud_print/print_system_win.cc
index ac090c2..550a5633 100644
--- a/chrome/service/cloud_print/print_system_win.cc
+++ b/chrome/service/cloud_print/print_system_win.cc
@@ -545,7 +545,7 @@ class PrinterCapsHandler : public ServiceUtilityProcessHost::Client {
           PrinterSemanticCapsAndDefaultsToCdd(semantic_info));
       if (description) {
         base::JSONWriter::WriteWithOptions(
-            description.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT,
+            *description, base::JSONWriter::OPTIONS_PRETTY_PRINT,
             &printer_info.printer_capabilities);
       }
     }
diff --git a/chrome/test/chromedriver/chrome/console_logger.cc b/chrome/test/chromedriver/chrome/console_logger.cc
index 9300e63..d555702 100644
--- a/chrome/test/chromedriver/chrome/console_logger.cc
+++ b/chrome/test/chromedriver/chrome/console_logger.cc
@@ -93,7 +93,7 @@ Status ConsoleLogger::OnEvent(
 
   // Don't know how to format, log full JSON.
   std::string message_json;
-  base::JSONWriter::Write(&params, &message_json);
+  base::JSONWriter::Write(params, &message_json);
   log_->AddEntry(Log::kWarning, message_json);
   return Status(kOk);
 }
diff --git a/chrome/test/chromedriver/chrome/devtools_client_impl.cc b/chrome/test/chromedriver/chrome/devtools_client_impl.cc
index 4992c80..56da77b 100644
--- a/chrome/test/chromedriver/chrome/devtools_client_impl.cc
+++ b/chrome/test/chromedriver/chrome/devtools_client_impl.cc
@@ -496,7 +496,7 @@ bool ParseInspectorMessage(
     if (message_dict->GetDictionary("result", &unscoped_result))
       command_response->result.reset(unscoped_result->DeepCopy());
     else if (message_dict->GetDictionary("error", &unscoped_error))
-      base::JSONWriter::Write(unscoped_error, &command_response->error);
+      base::JSONWriter::Write(*unscoped_error, &command_response->error);
     else
       command_response->result.reset(new base::DictionaryValue());
     return true;
diff --git a/chrome/test/chromedriver/chrome/devtools_client_impl_unittest.cc b/chrome/test/chromedriver/chrome/devtools_client_impl_unittest.cc
index 158caf3..4a0a4b0 100644
--- a/chrome/test/chromedriver/chrome/devtools_client_impl_unittest.cc
+++ b/chrome/test/chromedriver/chrome/devtools_client_impl_unittest.cc
@@ -70,7 +70,7 @@ class MockSyncWebSocket : public SyncWebSocket {
     base::DictionaryValue result;
     result.SetInteger("param", 1);
     response.Set("result", result.DeepCopy());
-    base::JSONWriter::Write(&response, message);
+    base::JSONWriter::Write(response, message);
     --queued_messages_;
     return SyncWebSocket::kOk;
   }
@@ -120,7 +120,7 @@ TEST_F(DevToolsClientImplTest, SendCommandAndGetResult) {
   Status status = client.SendCommandAndGetResult("method", params, &result);
   ASSERT_EQ(kOk, status.code());
   std::string json;
-  base::JSONWriter::Write(result.get(), &json);
+  base::JSONWriter::Write(*result, &json);
   ASSERT_STREQ("{\"param\":1}", json.c_str());
 }
 
@@ -725,7 +725,7 @@ class OnConnectedSyncWebSocket : public SyncWebSocket {
     response.SetInteger("id", id);
     response.Set("result", new base::DictionaryValue());
     std::string json_response;
-    base::JSONWriter::Write(&response, &json_response);
+    base::JSONWriter::Write(response, &json_response);
     queued_response_.push_back(json_response);
 
     // Push one event.
@@ -733,7 +733,7 @@ class OnConnectedSyncWebSocket : public SyncWebSocket {
     event.SetString("method", "updateEvent");
     event.Set("params", new base::DictionaryValue());
     std::string json_event;
-    base::JSONWriter::Write(&event, &json_event);
+    base::JSONWriter::Write(event, &json_event);
     queued_response_.push_back(json_event);
 
     return true;
diff --git a/chrome/test/chromedriver/chrome/dom_tracker.cc b/chrome/test/chromedriver/chrome/dom_tracker.cc
index 40f2f88..5f5fbcb 100644
--- a/chrome/test/chromedriver/chrome/dom_tracker.cc
+++ b/chrome/test/chromedriver/chrome/dom_tracker.cc
@@ -43,7 +43,7 @@ Status DomTracker::OnEvent(DevToolsClient* client,
 
     if (!ProcessNodeList(nodes)) {
       std::string json;
-      base::JSONWriter::Write(nodes, &json);
+      base::JSONWriter::Write(*nodes, &json);
       return Status(kUnknownError,
                     "DOM.setChildNodes has invalid 'nodes': " + json);
     }
@@ -54,7 +54,7 @@ Status DomTracker::OnEvent(DevToolsClient* client,
 
     if (!ProcessNode(node)) {
       std::string json;
-      base::JSONWriter::Write(node, &json);
+      base::JSONWriter::Write(*node, &json);
       return Status(kUnknownError,
                     "DOM.childNodeInserted has invalid 'node': " + json);
     }
diff --git a/chrome/test/chromedriver/chrome/frame_tracker.cc b/chrome/test/chromedriver/chrome/frame_tracker.cc
index c18b948..c87e0d8 100644
--- a/chrome/test/chromedriver/chrome/frame_tracker.cc
+++ b/chrome/test/chromedriver/chrome/frame_tracker.cc
@@ -52,7 +52,7 @@ Status FrameTracker::OnEvent(DevToolsClient* client,
     if (!context->GetInteger("id", &context_id) ||
         !context->GetString("frameId", &frame_id)) {
       std::string json;
-      base::JSONWriter::Write(context, &json);
+      base::JSONWriter::Write(*context, &json);
       return Status(
           kUnknownError,
           "Runtime.executionContextCreated has invalid 'context': " + json);
diff --git a/chrome/test/chromedriver/chrome/log.cc b/chrome/test/chromedriver/chrome/log.cc
index a40f9b2..ed1190a 100644
--- a/chrome/test/chromedriver/chrome/log.cc
+++ b/chrome/test/chromedriver/chrome/log.cc
@@ -85,7 +85,7 @@ bool IsVLogOn(int vlog_level) {
 std::string PrettyPrintValue(const base::Value& value) {
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
 #if defined(OS_WIN)
   base::RemoveChars(json, "\r", &json);
 #endif
diff --git a/chrome/test/chromedriver/chrome/util.cc b/chrome/test/chromedriver/chrome/util.cc
index b7f1a5c..02206f3 100644
--- a/chrome/test/chromedriver/chrome/util.cc
+++ b/chrome/test/chromedriver/chrome/util.cc
@@ -9,6 +9,6 @@
 
 std::string SerializeValue(const base::Value* value) {
   std::string json;
-  base::JSONWriter::Write(value, &json);
+  base::JSONWriter::Write(*value, &json);
   return json;
 }
diff --git a/chrome/test/chromedriver/chrome/web_view_impl.cc b/chrome/test/chromedriver/chrome/web_view_impl.cc
index c9cce52..9febe2b 100644
--- a/chrome/test/chromedriver/chrome/web_view_impl.cc
+++ b/chrome/test/chromedriver/chrome/web_view_impl.cc
@@ -237,7 +237,7 @@ Status WebViewImpl::CallFunction(const std::string& frame,
                                  const base::ListValue& args,
                                  scoped_ptr<base::Value>* result) {
   std::string json;
-  base::JSONWriter::Write(&args, &json);
+  base::JSONWriter::Write(args, &json);
   // TODO(zachconrad): Second null should be array of shadow host ids.
   std::string expression = base::StringPrintf(
       "(%s).apply(null, [null, %s, %s])",
@@ -763,7 +763,7 @@ Status GetNodeIdFromFunction(DevToolsClient* client,
                              bool* found_node,
                              int* node_id) {
   std::string json;
-  base::JSONWriter::Write(&args, &json);
+  base::JSONWriter::Write(args, &json);
   // TODO(zachconrad): Second null should be array of shadow host ids.
   std::string expression = base::StringPrintf(
       "(%s).apply(null, [null, %s, %s, true])",
diff --git a/chrome/test/chromedriver/chrome_launcher.cc b/chrome/test/chromedriver/chrome_launcher.cc
index dcf44d5..6326e14d 100644
--- a/chrome/test/chromedriver/chrome_launcher.cc
+++ b/chrome/test/chromedriver/chrome_launcher.cc
@@ -692,7 +692,7 @@ Status ProcessExtension(const std::string& extension,
     }
   } else {
     manifest->SetString("key", public_key_base64);
-    base::JSONWriter::Write(manifest, &manifest_data);
+    base::JSONWriter::Write(*manifest, &manifest_data);
     if (base::WriteFile(
             manifest_path, manifest_data.c_str(), manifest_data.size()) !=
         static_cast<int>(manifest_data.size())) {
@@ -788,7 +788,7 @@ Status WritePrefsFile(
   }
 
   std::string prefs_str;
-  base::JSONWriter::Write(prefs, &prefs_str);
+  base::JSONWriter::Write(*prefs, &prefs_str);
   VLOG(0) << "Populating " << path.BaseName().value()
           << " file: " << PrettyPrintValue(*prefs);
   if (static_cast<int>(prefs_str.length()) != base::WriteFile(
diff --git a/chrome/test/chromedriver/performance_logger.cc b/chrome/test/chromedriver/performance_logger.cc
index ea38f77..800e8ec 100644
--- a/chrome/test/chromedriver/performance_logger.cc
+++ b/chrome/test/chromedriver/performance_logger.cc
@@ -123,7 +123,7 @@ void PerformanceLogger::AddLogEntry(
   log_message_dict.SetString("message.method", method);
   log_message_dict.Set("message.params", params.DeepCopy());
   std::string log_message_json;
-  base::JSONWriter::Write(&log_message_dict, &log_message_json);
+  base::JSONWriter::Write(log_message_dict, &log_message_json);
 
   // TODO(klm): extract timestamp from params?
   // Look at where it is for Page, Network, Timeline, and trace events.
diff --git a/chrome/test/chromedriver/server/http_handler.cc b/chrome/test/chromedriver/server/http_handler.cc
index 279858c..157b94a 100644
--- a/chrome/test/chromedriver/server/http_handler.cc
+++ b/chrome/test/chromedriver/server/http_handler.cc
@@ -709,7 +709,7 @@ scoped_ptr<net::HttpServerResponseInfo> HttpHandler::PrepareResponseHelper(
   body_params.SetString("sessionId", session_id);
   std::string body;
   base::JSONWriter::WriteWithOptions(
-      &body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
+      body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &body);
   scoped_ptr<net::HttpServerResponseInfo> response(
       new net::HttpServerResponseInfo(net::HTTP_OK));
diff --git a/chrome/test/chromedriver/server/http_handler_unittest.cc b/chrome/test/chromedriver/server/http_handler_unittest.cc
index 55eaeb7..59c191f 100644
--- a/chrome/test/chromedriver/server/http_handler_unittest.cc
+++ b/chrome/test/chromedriver/server/http_handler_unittest.cc
@@ -74,7 +74,7 @@ TEST(HttpHandlerTest, HandleNewSession) {
   body.SetInteger("value", 1);
   body.SetString("sessionId", "session_id");
   std::string json;
-  base::JSONWriter::Write(&body, &json);
+  base::JSONWriter::Write(body, &json);
   ASSERT_EQ(json, response.body());
 }
 
@@ -119,7 +119,7 @@ TEST(HttpHandlerTest, HandleCommand) {
   body.SetInteger("value", 1);
   body.SetString("sessionId", "session_id");
   std::string json;
-  base::JSONWriter::Write(&body, &json);
+  base::JSONWriter::Write(body, &json);
   ASSERT_EQ(json, response.body());
 }
 
diff --git a/chromeos/dbus/shill_client_unittest_base.cc b/chromeos/dbus/shill_client_unittest_base.cc
index 184851a..de82bf0 100644
--- a/chromeos/dbus/shill_client_unittest_base.cc
+++ b/chromeos/dbus/shill_client_unittest_base.cc
@@ -54,7 +54,7 @@ bool ValueMatcher::MatchAndExplain(const base::Value& value,
 
 void ValueMatcher::DescribeTo(::std::ostream* os) const {
   std::string expected_value_str;
-  base::JSONWriter::WriteWithOptions(expected_value_.get(),
+  base::JSONWriter::WriteWithOptions(*expected_value_,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &expected_value_str);
   *os << "value equals " << expected_value_str;
@@ -62,7 +62,7 @@ void ValueMatcher::DescribeTo(::std::ostream* os) const {
 
 void ValueMatcher::DescribeNegationTo(::std::ostream* os) const {
   std::string expected_value_str;
-  base::JSONWriter::WriteWithOptions(expected_value_.get(),
+  base::JSONWriter::WriteWithOptions(*expected_value_,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &expected_value_str);
   *os << "value does not equal " << expected_value_str;
@@ -393,9 +393,9 @@ void ShillClientUnittestBase::ExpectDictionaryValueResultWithoutStatus(
     const base::DictionaryValue* expected_result,
     const base::DictionaryValue& result) {
   std::string expected_result_string;
-  base::JSONWriter::Write(expected_result, &expected_result_string);
+  base::JSONWriter::Write(*expected_result, &expected_result_string);
   std::string result_string;
-  base::JSONWriter::Write(&result, &result_string);
+  base::JSONWriter::Write(result, &result_string);
   EXPECT_EQ(expected_result_string, result_string);
 }
 
diff --git a/chromeos/network/network_configuration_handler.cc b/chromeos/network/network_configuration_handler.cc
index d095e57..ac7ea8b 100644
--- a/chromeos/network/network_configuration_handler.cc
+++ b/chromeos/network/network_configuration_handler.cc
@@ -65,7 +65,7 @@ void LogConfigProperties(const std::string& desc,
        iter.Advance()) {
     std::string v = "******";
     if (shill_property_util::IsLoggableShillProperty(iter.key()))
-      base::JSONWriter::Write(&iter.value(), &v);
+      base::JSONWriter::Write(iter.value(), &v);
     NET_LOG(USER) << desc << ": " << path + "." + iter.key() + "=" + v;
   }
 }
diff --git a/chromeos/network/network_configuration_handler_unittest.cc b/chromeos/network/network_configuration_handler_unittest.cc
index 2772fc9..2b79c4c 100644
--- a/chromeos/network/network_configuration_handler_unittest.cc
+++ b/chromeos/network/network_configuration_handler_unittest.cc
@@ -46,7 +46,7 @@ namespace {
 static std::string PrettyJson(const base::DictionaryValue& value) {
   std::string pretty;
   base::JSONWriter::WriteWithOptions(
-      &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty);
+      value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty);
   return pretty;
 }
 
diff --git a/chromeos/network/network_state_handler.cc b/chromeos/network/network_state_handler.cc
index a8a9ebf..e7ddbcf 100644
--- a/chromeos/network/network_state_handler.cc
+++ b/chromeos/network/network_state_handler.cc
@@ -56,7 +56,7 @@ std::string GetLogName(const ManagedState* state) {
 std::string ValueAsString(const base::Value& value) {
   std::string vstr;
   base::JSONWriter::WriteWithOptions(
-      &value, base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &vstr);
+      value, base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &vstr);
   return vstr.empty() ? "''" : vstr;
 }
 
diff --git a/chromeos/network/onc/onc_translator_onc_to_shill.cc b/chromeos/network/onc/onc_translator_onc_to_shill.cc
index 9cea033..33b9e8d 100644
--- a/chromeos/network/onc/onc_translator_onc_to_shill.cc
+++ b/chromeos/network/onc/onc_translator_onc_to_shill.cc
@@ -31,7 +31,7 @@ namespace {
 scoped_ptr<base::StringValue> ConvertValueToString(const base::Value& value) {
   std::string str;
   if (!value.GetAsString(&str))
-    base::JSONWriter::Write(&value, &str);
+    base::JSONWriter::Write(value, &str);
   return make_scoped_ptr(new base::StringValue(str));
 }
 
diff --git a/chromeos/network/shill_property_util.cc b/chromeos/network/shill_property_util.cc
index a53487b..30a6925 100644
--- a/chromeos/network/shill_property_util.cc
+++ b/chromeos/network/shill_property_util.cc
@@ -221,7 +221,7 @@ void SetUIData(const NetworkUIData& ui_data,
   base::DictionaryValue ui_data_dict;
   ui_data.FillDictionary(&ui_data_dict);
   std::string ui_data_blob;
-  base::JSONWriter::Write(&ui_data_dict, &ui_data_blob);
+  base::JSONWriter::Write(ui_data_dict, &ui_data_blob);
   shill_dictionary->SetStringWithoutPathExpansion(shill::kUIDataProperty,
                                                   ui_data_blob);
 }
diff --git a/cloud_print/gcp20/prototype/cloud_print_requester.cc b/cloud_print/gcp20/prototype/cloud_print_requester.cc
index d46fdf4..cbfdae4 100644
--- a/cloud_print/gcp20/prototype/cloud_print_requester.cc
+++ b/cloud_print/gcp20/prototype/cloud_print_requester.cc
@@ -86,10 +86,10 @@ std::string LocalSettingsToJson(const LocalSettings& settings) {
   current->SetBoolean("printer/local_printing_enabled",
                          settings.local_printing_enabled);
   current->SetInteger("xmpp_timeout_value", settings.xmpp_timeout_value);
-  dictionary.Set("current", current.release());
+  dictionary.Set("current", current.Pass());
 
   std::string local_settings;
-  base::JSONWriter::Write(&dictionary, &local_settings);
+  base::JSONWriter::Write(dictionary, &local_settings);
   return local_settings;
 }
 
diff --git a/cloud_print/gcp20/prototype/printer.cc b/cloud_print/gcp20/prototype/printer.cc
index 9820ace..4309002 100644
--- a/cloud_print/gcp20/prototype/printer.cc
+++ b/cloud_print/gcp20/prototype/printer.cc
@@ -193,7 +193,7 @@ void Printer::Stop() {
 
 std::string Printer::GetRawCdd() {
   std::string json_str;
-  base::JSONWriter::WriteWithOptions(&GetCapabilities(),
+  base::JSONWriter::WriteWithOptions(GetCapabilities(),
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &json_str);
   return json_str;
diff --git a/cloud_print/gcp20/prototype/printer_state.cc b/cloud_print/gcp20/prototype/printer_state.cc
index 9dedf1d..0d8fead 100644
--- a/cloud_print/gcp20/prototype/printer_state.cc
+++ b/cloud_print/gcp20/prototype/printer_state.cc
@@ -71,7 +71,7 @@ bool SaveToFile(const base::FilePath& path, const PrinterState& state) {
     json.Set(kCdd, state.cdd->DeepCopy());
 
   std::string json_str;
-  base::JSONWriter::WriteWithOptions(&json,
+  base::JSONWriter::WriteWithOptions(json,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &json_str);
   int size = base::checked_cast<int>(json_str.size());
diff --git a/cloud_print/gcp20/prototype/privet_http_server.cc b/cloud_print/gcp20/prototype/privet_http_server.cc
index c033439..90b45a8 100644
--- a/cloud_print/gcp20/prototype/privet_http_server.cc
+++ b/cloud_print/gcp20/prototype/privet_http_server.cc
@@ -234,7 +234,7 @@ net::HttpStatusCode PrivetHttpServer::ProcessHttpRequest(
     return status_code;
   }
 
-  base::JSONWriter::WriteWithOptions(json_response.get(),
+  base::JSONWriter::WriteWithOptions(*json_response,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      response);
   return status_code;
diff --git a/cloud_print/service/service_state.cc b/cloud_print/service/service_state.cc
index f98c513..789d229 100644
--- a/cloud_print/service/service_state.cc
+++ b/cloud_print/service/service_state.cc
@@ -134,8 +134,6 @@ bool ServiceState::IsValid() const {
 }
 
 std::string ServiceState::ToString() {
-  scoped_ptr<base::DictionaryValue> services(new base::DictionaryValue());
-
   scoped_ptr<base::DictionaryValue> cloud_print(new base::DictionaryValue());
   cloud_print->SetBoolean(kEnabledOptionName, true);
 
@@ -147,12 +145,12 @@ std::string ServiceState::ToString() {
   SetNotEmptyJsonString(cloud_print.get(), kXmppAuthTokenOptionName,
                         xmpp_auth_token_);
 
-  services->Set(kCloudPrintJsonName, cloud_print.release());
+  base::DictionaryValue services;
+  services.Set(kCloudPrintJsonName, cloud_print.Pass());
 
   std::string json;
-  base::JSONWriter::WriteWithOptions(services.get(),
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
+  base::JSONWriter::WriteWithOptions(
+      services, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/cloud_print/service/win/chrome_launcher.cc b/cloud_print/service/win/chrome_launcher.cc
index adf9c24..e9bcee1 100644
--- a/cloud_print/service/win/chrome_launcher.cc
+++ b/cloud_print/service/win/chrome_launcher.cc
@@ -133,7 +133,7 @@ std::string ReadAndUpdateServiceState(const base::FilePath& directory,
   if (!proxy_id.empty())  // Reuse proxy id if we already had one.
     dictionary->SetString(prefs::kCloudPrintProxyId, proxy_id);
   std::string result;
-  base::JSONWriter::WriteWithOptions(dictionary,
+  base::JSONWriter::WriteWithOptions(*dictionary,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &result);
   return result;
@@ -276,7 +276,7 @@ std::string ChromeLauncher::CreateServiceStateFile(
   base::ListValue printer_list;
   printer_list.AppendStrings(printers);
   std::string printers_json;
-  base::JSONWriter::Write(&printer_list, &printers_json);
+  base::JSONWriter::Write(printer_list, &printers_json);
   size_t written = base::WriteFile(printers_file,
                                    printers_json.c_str(),
                                    printers_json.size());
diff --git a/cloud_print/service/win/service_listener.cc b/cloud_print/service/win/service_listener.cc
index f4af6dd..497aff76 100644
--- a/cloud_print/service/win/service_listener.cc
+++ b/cloud_print/service/win/service_listener.cc
@@ -49,7 +49,7 @@ std::string GetEnvironment(const base::FilePath& user_data_dir) {
   }
 
   std::string result;
-  base::JSONWriter::Write(&environment, &result);
+  base::JSONWriter::Write(environment, &result);
   return result;
 }
 
diff --git a/components/autofill/content/browser/wallet/wallet_client.cc b/components/autofill/content/browser/wallet/wallet_client.cc
index b5cd15e..e599b2e 100644
--- a/components/autofill/content/browser/wallet/wallet_client.cc
+++ b/components/autofill/content/browser/wallet/wallet_client.cc
@@ -295,7 +295,7 @@ void WalletClient::AuthenticateInstrument(
   request_dict.SetString(kInstrumentIdKey, instrument_id);
 
   std::string json_payload;
-  base::JSONWriter::Write(&request_dict, &json_payload);
+  base::JSONWriter::Write(request_dict, &json_payload);
 
   std::string escaped_card_verification_number = net::EscapeUrlEncodedData(
       card_verification_number, true);
@@ -339,7 +339,7 @@ void WalletClient::GetFullWallet(const FullWalletRequest& full_wallet_request) {
   request_dict.Set(kRiskCapabilitiesKey, risk_capabilities_list.release());
 
   std::string json_payload;
-  base::JSONWriter::Write(&request_dict, &json_payload);
+  base::JSONWriter::Write(request_dict, &json_payload);
 
   crypto::RandBytes(&(one_time_pad_[0]), one_time_pad_.size());
 
@@ -431,7 +431,7 @@ void WalletClient::SaveToWallet(
   }
 
   std::string json_payload;
-  base::JSONWriter::Write(&request_dict, &json_payload);
+  base::JSONWriter::Write(request_dict, &json_payload);
 
   if (!card_verification_number.empty()) {
     std::string post_body;
@@ -476,7 +476,7 @@ void WalletClient::GetWalletItems(const base::string16& amount,
     request_dict.SetString(kTransactionCurrencyKey, currency);
 
   std::string post_body;
-  base::JSONWriter::Write(&request_dict, &post_body);
+  base::JSONWriter::Write(request_dict, &post_body);
 
   MakeWalletRequest(GetGetWalletItemsUrl(user_index_),
                     post_body,
@@ -515,7 +515,7 @@ void WalletClient::DoAcceptLegalDocuments(
   request_dict.Set(kAcceptedLegalDocumentKey, docs_list.release());
 
   std::string post_body;
-  base::JSONWriter::Write(&request_dict, &post_body);
+  base::JSONWriter::Write(request_dict, &post_body);
 
   MakeWalletRequest(GetAcceptLegalDocumentsUrl(user_index_),
                     post_body,
diff --git a/components/autofill/content/browser/wallet/wallet_client_unittest.cc b/components/autofill/content/browser/wallet/wallet_client_unittest.cc
index 230776f..a57bbf5 100644
--- a/components/autofill/content/browser/wallet/wallet_client_unittest.cc
+++ b/components/autofill/content/browser/wallet/wallet_client_unittest.cc
@@ -876,7 +876,7 @@ class WalletClientTest : public testing::Test {
         static_cast<base::DictionaryValue*>(root.get());
     dict->Remove("api_key", NULL);
     std::string clean_upload_data;
-    base::JSONWriter::Write(dict, &clean_upload_data);
+    base::JSONWriter::Write(*dict, &clean_upload_data);
     return clean_upload_data;
   }
 
diff --git a/components/autofill/core/browser/wallet/real_pan_wallet_client.cc b/components/autofill/core/browser/wallet/real_pan_wallet_client.cc
index 9d41ab4..ec7adb5 100644
--- a/components/autofill/core/browser/wallet/real_pan_wallet_client.cc
+++ b/components/autofill/core/browser/wallet/real_pan_wallet_client.cc
@@ -244,7 +244,7 @@ void RealPanWalletClient::CreateRequest() {
     request_dict.SetInteger("expiration_year", value);
 
   std::string json_request;
-  base::JSONWriter::Write(&request_dict, &json_request);
+  base::JSONWriter::Write(request_dict, &json_request);
   std::string post_body =
       base::StringPrintf(kUnmaskCardRequestFormat,
                          net::EscapeUrlEncodedData(json_request, true).c_str(),
diff --git a/components/autofill/core/common/password_form.cc b/components/autofill/core/common/password_form.cc
index 41ca1fc..e5edaca 100644
--- a/components/autofill/core/common/password_form.cc
+++ b/components/autofill/core/common/password_form.cc
@@ -160,7 +160,7 @@ std::ostream& operator<<(std::ostream& os, const PasswordForm& form) {
 
   std::string form_as_string;
   base::JSONWriter::WriteWithOptions(
-      &form_json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &form_as_string);
+      form_json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &form_as_string);
   base::TrimWhitespaceASCII(form_as_string, base::TRIM_ALL, &form_as_string);
   return os << "PasswordForm(" << form_as_string << ")";
 }
diff --git a/components/autofill/core/common/save_password_progress_logger.cc b/components/autofill/core/common/save_password_progress_logger.cc
index 2fe68c9..f6da10c 100644
--- a/components/autofill/core/common/save_password_progress_logger.cc
+++ b/components/autofill/core/common/save_password_progress_logger.cc
@@ -143,7 +143,7 @@ void SavePasswordProgressLogger::LogMessage(
 void SavePasswordProgressLogger::LogValue(StringID label, const Value& log) {
   std::string log_string;
   bool conversion_to_string_successful = base::JSONWriter::WriteWithOptions(
-      &log, base::JSONWriter::OPTIONS_PRETTY_PRINT, &log_string);
+      log, base::JSONWriter::OPTIONS_PRETTY_PRINT, &log_string);
   DCHECK(conversion_to_string_successful);
   SendLog(GetStringFromID(label) + ": " + log_string);
 }
diff --git a/components/cloud_devices/common/cloud_device_description.cc b/components/cloud_devices/common/cloud_device_description.cc
index d1cb504..ba29908 100644
--- a/components/cloud_devices/common/cloud_device_description.cc
+++ b/components/cloud_devices/common/cloud_device_description.cc
@@ -47,7 +47,7 @@ bool CloudDeviceDescription::InitFromString(const std::string& json) {
 std::string CloudDeviceDescription::ToString() const {
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      root_.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      *root_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/components/cloud_devices/common/printer_description_unittest.cc b/components/cloud_devices/common/printer_description_unittest.cc
index c1fb455..5c8b182 100644
--- a/components/cloud_devices/common/printer_description_unittest.cc
+++ b/components/cloud_devices/common/printer_description_unittest.cc
@@ -22,7 +22,7 @@ std::string NormalizeJson(const std::string& json) {
   base::ReplaceChars(result, "'", "\"", &result);
   scoped_ptr<base::Value> value(base::JSONReader::Read(result));
   DCHECK(value);
-  base::JSONWriter::Write(value.get(), &result);
+  base::JSONWriter::Write(*value, &result);
   return result;
 }
 
diff --git a/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.cc b/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.cc
index d6895cd..b805682 100644
--- a/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.cc
+++ b/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.cc
@@ -198,7 +198,7 @@ DataReductionProxyConfigServiceClient::ConstructStaticResponse() const {
   scoped_ptr<base::DictionaryValue> values(new base::DictionaryValue());
   params_->PopulateConfigResponse(values.get());
   request_options_->PopulateConfigResponse(values.get());
-  base::JSONWriter::Write(values.get(), &response);
+  base::JSONWriter::Write(*values, &response);
 
   return response;
 }
diff --git a/components/devtools_http_handler/devtools_http_handler.cc b/components/devtools_http_handler/devtools_http_handler.cc
index 3c9a8e7..67c061c 100644
--- a/components/devtools_http_handler/devtools_http_handler.cc
+++ b/components/devtools_http_handler/devtools_http_handler.cc
@@ -813,13 +813,11 @@ void DevToolsHttpHandler::SendJson(int connection_id,
   // Serialize value and message.
   std::string json_value;
   if (value) {
-    base::JSONWriter::WriteWithOptions(value,
-                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                       &json_value);
+    base::JSONWriter::WriteWithOptions(
+        *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_value);
   }
   std::string json_message;
-  scoped_ptr<base::Value> message_object(new base::StringValue(message));
-  base::JSONWriter::Write(message_object.get(), &json_message);
+  base::JSONWriter::Write(base::StringValue(message), &json_message);
 
   net::HttpServerResponseInfo response(status_code);
   response.SetBody(json_value + message, "application/json; charset=UTF-8");
diff --git a/components/dom_distiller/core/distiller_page.cc b/components/dom_distiller/core/distiller_page.cc
index 8eb6585..74e6f1c 100644
--- a/components/dom_distiller/core/distiller_page.cc
+++ b/components/dom_distiller/core/distiller_page.cc
@@ -40,7 +40,7 @@ std::string GetDistillerScriptWithOptions(
   scoped_ptr<base::Value> options_value(
       dom_distiller::proto::json::DomDistillerOptions::WriteToValue(options));
   std::string options_json;
-  if (!base::JSONWriter::Write(options_value.get(), &options_json)) {
+  if (!base::JSONWriter::Write(*options_value, &options_json)) {
     NOTREACHED();
   }
   size_t options_offset = script.find(kOptionsPlaceholder);
diff --git a/components/dom_distiller/core/page_features_unittest.cc b/components/dom_distiller/core/page_features_unittest.cc
index 413c55f..1fee593 100644
--- a/components/dom_distiller/core/page_features_unittest.cc
+++ b/components/dom_distiller/core/page_features_unittest.cc
@@ -70,7 +70,7 @@ TEST(DomDistillerPageFeaturesTest, TestCalculateDerivedFeatures) {
     // CalculateDerivedFeaturesFromJSON expects a base::Value of the stringified
     // JSON (and not a base::Value of the JSON itself)
     std::string stringified_json;
-    ASSERT_TRUE(base::JSONWriter::Write(core_features, &stringified_json));
+    ASSERT_TRUE(base::JSONWriter::Write(*core_features, &stringified_json));
     scoped_ptr<base::Value> stringified_value(
         new base::StringValue(stringified_json));
     std::vector<double> derived(
diff --git a/components/dom_distiller/core/viewer.cc b/components/dom_distiller/core/viewer.cc
index e19f378..0244a4f 100644
--- a/components/dom_distiller/core/viewer.cc
+++ b/components/dom_distiller/core/viewer.cc
@@ -159,9 +159,9 @@ const std::string GetShowFeedbackFormJs() {
   std::string yes;
   std::string no;
 
-  base::JSONWriter::Write(&question_val, &question);
-  base::JSONWriter::Write(&yes_val, &yes);
-  base::JSONWriter::Write(&no_val, &no);
+  base::JSONWriter::Write(question_val, &question);
+  base::JSONWriter::Write(yes_val, &yes);
+  base::JSONWriter::Write(no_val, &no);
 
   return "showFeedbackForm(" + question + ", " + yes + ", " + no + ");";
 }
@@ -172,7 +172,7 @@ const std::string GetUnsafeIncrementalDistilledPageJs(
   std::string output(page_proto->html());
   EnsureNonEmptyContent(&output);
   base::StringValue value(output);
-  base::JSONWriter::Write(&value, &output);
+  base::JSONWriter::Write(value, &output);
   std::string page_update("addToPage(");
   page_update += output + ");";
   return page_update + GetToggleLoadingIndicatorJs(
@@ -184,7 +184,7 @@ const std::string GetErrorPageJs() {
   base::StringValue value(l10n_util::GetStringUTF8(
       IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_CONTENT));
   std::string output;
-  base::JSONWriter::Write(&value, &output);
+  base::JSONWriter::Write(value, &output);
   std::string page_update("addToPage(");
   page_update += output + ");";
   return page_update;
@@ -226,8 +226,7 @@ const std::string GetUnsafeArticleContentJs(
 
   std::string output(unsafe_output_stream.str());
   EnsureNonEmptyContent(&output);
-  base::StringValue value(output);
-  base::JSONWriter::Write(&value, &output);
+  base::JSONWriter::Write(base::StringValue(output), &output);
   std::string page_update("addToPage(");
   page_update += output + ");";
   return page_update + GetToggleLoadingIndicatorJs(true);
diff --git a/components/domain_reliability/context.cc b/components/domain_reliability/context.cc
index 230581f..5a35090 100644
--- a/components/domain_reliability/context.cc
+++ b/components/domain_reliability/context.cc
@@ -223,9 +223,7 @@ void DomainReliabilityContext::StartUpload() {
   DCHECK(upload_time_.is_null());
   upload_time_ = time_->NowTicks();
   std::string report_json;
-  scoped_ptr<const Value> report_value(CreateReport(upload_time_));
-  base::JSONWriter::Write(report_value.get(), &report_json);
-  report_value.reset();
+  base::JSONWriter::Write(*CreateReport(upload_time_), &report_json);
 
   size_t collector_index = scheduler_.OnUploadStart();
 
@@ -281,7 +279,7 @@ scoped_ptr<const Value> DomainReliabilityContext::CreateReport(
       resources_value->Append(resource_report.release());
   }
 
-  DictionaryValue* report_value = new DictionaryValue();
+  scoped_ptr<DictionaryValue> report_value(new DictionaryValue());
   if (!config().version.empty())
     report_value->SetString("config_version", config().version);
   report_value->SetString("reporter", upload_reporter_string_);
@@ -289,7 +287,7 @@ scoped_ptr<const Value> DomainReliabilityContext::CreateReport(
   if (!resources_value->empty())
     report_value->Set("resources", resources_value.release());
 
-  return scoped_ptr<const Value>(report_value);
+  return report_value.Pass();
 }
 
 void DomainReliabilityContext::MarkUpload() {
diff --git a/components/error_page/renderer/net_error_helper_core.cc b/components/error_page/renderer/net_error_helper_core.cc
index 9a92d74..0c89ec3c 100644
--- a/components/error_page/renderer/net_error_helper_core.cc
+++ b/components/error_page/renderer/net_error_helper_core.cc
@@ -198,7 +198,7 @@ std::string CreateRequestBody(
   request_dict.Set("params", params_dict.release());
 
   std::string request_body;
-  bool success = base::JSONWriter::Write(&request_dict, &request_body);
+  bool success = base::JSONWriter::Write(request_dict, &request_body);
   DCHECK(success);
   return request_body;
 }
diff --git a/components/error_page/renderer/net_error_helper_core_unittest.cc b/components/error_page/renderer/net_error_helper_core_unittest.cc
index 97897fb..5ec9377 100644
--- a/components/error_page/renderer/net_error_helper_core_unittest.cc
+++ b/components/error_page/renderer/net_error_helper_core_unittest.cc
@@ -84,13 +84,13 @@ std::string SuggestionsToResponse(const NavigationCorrection* corrections,
   for (int i = 0; i < num_corrections; ++i)
     url_corrections->Append(corrections[i].ToValue());
 
-  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
-  response->Set("result.UrlCorrections", url_corrections);
-  response->SetString("result.eventId", kNavigationCorrectionEventId);
-  response->SetString("result.fingerprint", kNavigationCorrectionFingerprint);
+  base::DictionaryValue response;
+  response.Set("result.UrlCorrections", url_corrections);
+  response.SetString("result.eventId", kNavigationCorrectionEventId);
+  response.SetString("result.fingerprint", kNavigationCorrectionFingerprint);
 
   std::string json;
-  base::JSONWriter::Write(response.get(), &json);
+  base::JSONWriter::Write(response, &json);
   return json;
 }
 
diff --git a/components/history/core/browser/delete_directive_handler.cc b/components/history/core/browser/delete_directive_handler.cc
index 0aba13f..71d7f03 100644
--- a/components/history/core/browser/delete_directive_handler.cc
+++ b/components/history/core/browser/delete_directive_handler.cc
@@ -32,7 +32,7 @@ std::string DeleteDirectiveToString(
   scoped_ptr<base::DictionaryValue> value(
       syncer::HistoryDeleteDirectiveSpecificsToValue(delete_directive));
   std::string str;
-  base::JSONWriter::Write(value.get(), &str);
+  base::JSONWriter::Write(*value, &str);
   return str;
 }
 
diff --git a/components/history/core/browser/web_history_service.cc b/components/history/core/browser/web_history_service.cc
index 4a8b3aa..b4047f6 100644
--- a/components/history/core/browser/web_history_service.cc
+++ b/components/history/core/browser/web_history_service.cc
@@ -362,7 +362,7 @@ void WebHistoryService::ExpireHistory(
   }
   delete_request.Set("del", deletions.release());
   std::string post_data;
-  base::JSONWriter::Write(&delete_request, &post_data);
+  base::JSONWriter::Write(delete_request, &post_data);
 
   GURL url(kHistoryDeleteHistoryUrl);
 
@@ -426,7 +426,7 @@ void WebHistoryService::SetAudioHistoryEnabled(
                                   new_enabled_value);
   enable_audio_history.SetString("client", "audio");
   std::string post_data;
-  base::JSONWriter::Write(&enable_audio_history, &post_data);
+  base::JSONWriter::Write(enable_audio_history, &post_data);
   request->SetPostData(post_data);
 
   request->Start();
diff --git a/components/invalidation/invalidation_test_util.cc b/components/invalidation/invalidation_test_util.cc
index 3368797..6fcd8ef 100644
--- a/components/invalidation/invalidation_test_util.cc
+++ b/components/invalidation/invalidation_test_util.cc
@@ -99,9 +99,8 @@ void InvalidationEqMatcher::DescribeNegationTo(::std::ostream* os) const {
 }  // namespace
 
 void PrintTo(const AckHandle& ack_handle, ::std::ostream* os) {
-  scoped_ptr<base::Value> value(ack_handle.ToValue());
   std::string printable_ack_handle;
-  base::JSONWriter::Write(value.get(), &printable_ack_handle);
+  base::JSONWriter::Write(*ack_handle.ToValue(), &printable_ack_handle);
   *os << "{ ack_handle: " << printable_ack_handle << " }";
 }
 
diff --git a/components/invalidation/invalidation_util.cc b/components/invalidation/invalidation_util.cc
index 50e3a5c..d3706f4 100644
--- a/components/invalidation/invalidation_util.cc
+++ b/components/invalidation/invalidation_util.cc
@@ -61,9 +61,8 @@ bool ObjectIdFromValue(const base::DictionaryValue& value,
 }
 
 std::string ObjectIdToString(const invalidation::ObjectId& object_id) {
-  scoped_ptr<base::DictionaryValue> value(ObjectIdToValue(object_id));
   std::string str;
-  base::JSONWriter::Write(value.get(), &str);
+  base::JSONWriter::Write(*ObjectIdToValue(object_id), &str);
   return str;
 }
 
diff --git a/components/invalidation/p2p_invalidator.cc b/components/invalidation/p2p_invalidator.cc
index c583d44..906a201 100644
--- a/components/invalidation/p2p_invalidator.cc
+++ b/components/invalidation/p2p_invalidator.cc
@@ -102,13 +102,12 @@ bool P2PNotificationData::Equals(const P2PNotificationData& other) const {
 }
 
 std::string P2PNotificationData::ToString() const {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString(kSenderIdKey, sender_id_);
-  dict->SetString(kNotificationTypeKey,
-                  P2PNotificationTargetToString(target_));
-  dict->Set(kInvalidationsKey, invalidation_map_.ToValue().release());
+  base::DictionaryValue dict;
+  dict.SetString(kSenderIdKey, sender_id_);
+  dict.SetString(kNotificationTypeKey, P2PNotificationTargetToString(target_));
+  dict.Set(kInvalidationsKey, invalidation_map_.ToValue().release());
   std::string json;
-  base::JSONWriter::Write(dict.get(), &json);
+  base::JSONWriter::Write(dict, &json);
   return json;
 }
 
diff --git a/components/nacl/renderer/ppb_nacl_private_impl.cc b/components/nacl/renderer/ppb_nacl_private_impl.cc
index 5ebc61f..e77b977 100644
--- a/components/nacl/renderer/ppb_nacl_private_impl.cc
+++ b/components/nacl/renderer/ppb_nacl_private_impl.cc
@@ -1190,12 +1190,12 @@ PP_Bool GetPNaClResourceInfo(PP_Instance instance,
   base::JSONReader json_reader;
   int json_read_error_code;
   std::string json_read_error_msg;
-  base::Value* json_data = json_reader.ReadAndReturnError(
+  scoped_ptr<base::Value> json_data(json_reader.ReadAndReturnError(
       buffer.get(),
       base::JSON_PARSE_RFC,
       &json_read_error_code,
-      &json_read_error_msg);
-  if (json_data == NULL) {
+      &json_read_error_msg));
+  if (!json_data) {
     load_manager->ReportLoadError(
         PP_NACL_ERROR_PNACL_RESOURCE_FETCH,
         std::string("Parsing resource info failed: JSON parse error: ") +
diff --git a/components/omnibox/search_suggestion_parser.cc b/components/omnibox/search_suggestion_parser.cc
index 96933cf..26d1933 100644
--- a/components/omnibox/search_suggestion_parser.cc
+++ b/components/omnibox/search_suggestion_parser.cc
@@ -518,7 +518,7 @@ bool SearchSuggestionParser::ParseSuggestResults(
               answer->AddImageURLsTo(&results->answers_image_urls);
 
               std::string contents;
-              base::JSONWriter::Write(answer_json, &contents);
+              base::JSONWriter::Write(*answer_json, &contents);
               answer_contents = base::UTF8ToUTF16(contents);
             } else {
               answer_type_str = base::string16();
diff --git a/components/policy/core/common/cloud/policy_header_service.cc b/components/policy/core/common/cloud/policy_header_service.cc
index d0f6980..62519c75 100644
--- a/components/policy/core/common/cloud/policy_header_service.cc
+++ b/components/policy/core/common/cloud/policy_header_service.cc
@@ -74,7 +74,7 @@ std::string PolicyHeaderService::CreateHeaderValue() {
   // TODO(atwilson): add user_policy_token once the server starts sending it
   // down (http://crbug.com/326799).
   std::string json;
-  base::JSONWriter::Write(&value, &json);
+  base::JSONWriter::Write(value, &json);
   DCHECK(!json.empty());
 
   // Base64-encode the result so we can include it in a header.
diff --git a/components/policy/core/common/policy_loader_win.cc b/components/policy/core/common/policy_loader_win.cc
index f223da5..f49f944e 100644
--- a/components/policy/core/common/policy_loader_win.cc
+++ b/components/policy/core/common/policy_loader_win.cc
@@ -128,7 +128,7 @@ std::string PatchSchema(const std::string& schema) {
   }
 
   std::string serialized;
-  base::JSONWriter::Write(json.get(), &serialized);
+  base::JSONWriter::Write(*json, &serialized);
   return serialized;
 }
 
diff --git a/components/policy/core/common/policy_loader_win_unittest.cc b/components/policy/core/common/policy_loader_win_unittest.cc
index 76adc44..c2db3f2 100644
--- a/components/policy/core/common/policy_loader_win_unittest.cc
+++ b/components/policy/core/common/policy_loader_win_unittest.cc
@@ -402,7 +402,7 @@ void RegistryTestHarness::InstallDictionaryPolicy(
     const std::string& policy_name,
     const base::DictionaryValue* policy_value) {
   std::string json;
-  base::JSONWriter::Write(policy_value, &json);
+  base::JSONWriter::Write(*policy_value, &json);
   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
@@ -506,7 +506,7 @@ void PRegTestHarness::InstallDictionaryPolicy(
     const std::string& policy_name,
     const base::DictionaryValue* policy_value) {
   std::string json;
-  base::JSONWriter::Write(policy_value, &json);
+  base::JSONWriter::Write(*policy_value, &json);
   AppendStringToPRegFile(kTestPolicyKey, policy_name, json);
 }
 
@@ -910,11 +910,11 @@ TEST_F(PolicyLoaderWinTest, LoadStringEncodedValues) {
   policy.Set("list", list.DeepCopy());
   // Encode |policy| before adding the "dict" entry.
   std::string encoded_dict;
-  base::JSONWriter::Write(&policy, &encoded_dict);
+  base::JSONWriter::Write(policy, &encoded_dict);
   ASSERT_FALSE(encoded_dict.empty());
   policy.Set("dict", policy.DeepCopy());
   std::string encoded_list;
-  base::JSONWriter::Write(&list, &encoded_list);
+  base::JSONWriter::Write(list, &encoded_list);
   ASSERT_FALSE(encoded_list.empty());
   base::DictionaryValue encoded_policy;
   encoded_policy.SetString("null", "");
diff --git a/components/policy/core/common/policy_test_utils.cc b/components/policy/core/common/policy_test_utils.cc
index 79180e4..e9116b7 100644
--- a/components/policy/core/common/policy_test_utils.cc
+++ b/components/policy/core/common/policy_test_utils.cc
@@ -222,9 +222,8 @@ std::ostream& operator<<(std::ostream& os, const policy::PolicyMap& policies) {
 
 std::ostream& operator<<(std::ostream& os, const policy::PolicyMap::Entry& e) {
   std::string value;
-  base::JSONWriter::WriteWithOptions(e.value,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &value);
+  base::JSONWriter::WriteWithOptions(
+      *e.value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &value);
   os << "{" << std::endl
      << "  \"level\": " << e.level << "," << std::endl
      << "  \"scope\": " << e.scope << "," << std::endl
diff --git a/components/printing/renderer/print_web_view_helper.cc b/components/printing/renderer/print_web_view_helper.cc
index 7d1b907..bd6267c 100644
--- a/components/printing/renderer/print_web_view_helper.cc
+++ b/components/printing/renderer/print_web_view_helper.cc
@@ -83,7 +83,7 @@ void ExecuteScript(blink::WebFrame* frame,
                    const char* script_format,
                    const base::Value& parameters) {
   std::string json;
-  base::JSONWriter::Write(&parameters, &json);
+  base::JSONWriter::Write(parameters, &json);
   std::string script = base::StringPrintf(script_format, json.c_str());
   frame->executeScript(blink::WebString(base::UTF8ToUTF16(script)));
 }
diff --git a/components/proximity_auth/client.cc b/components/proximity_auth/client.cc
index a0b6a06..255b6f6 100644
--- a/components/proximity_auth/client.cc
+++ b/components/proximity_auth/client.cc
@@ -37,7 +37,7 @@ const char kUnlockEventName[] = "easy_unlock";
 // Serializes the |value| to a JSON string and returns the result.
 std::string SerializeValueToJson(const base::Value& value) {
   std::string json;
-  base::JSONWriter::Write(&value, &json);
+  base::JSONWriter::Write(value, &json);
   return json;
 }
 
diff --git a/components/search_engines/keyword_table.cc b/components/search_engines/keyword_table.cc
index 3e21c1f..7de6217 100644
--- a/components/search_engines/keyword_table.cc
+++ b/components/search_engines/keyword_table.cc
@@ -100,7 +100,7 @@ void BindURLToStatement(const TemplateURLData& data,
   for (size_t i = 0; i < data.alternate_urls.size(); ++i)
     alternate_urls_value.AppendString(data.alternate_urls[i]);
   std::string alternate_urls;
-  base::JSONWriter::Write(&alternate_urls_value, &alternate_urls);
+  base::JSONWriter::Write(alternate_urls_value, &alternate_urls);
 
   s->BindInt64(id_column, data.id);
   s->BindString16(starting_column, data.short_name());
diff --git a/components/search_provider_logos/logo_cache.cc b/components/search_provider_logos/logo_cache.cc
index bfa419e..c6272ee 100644
--- a/components/search_provider_logos/logo_cache.cc
+++ b/components/search_provider_logos/logo_cache.cc
@@ -152,7 +152,7 @@ void LogoCache::LogoMetadataToString(const LogoMetadata& metadata,
                   metadata.can_show_after_expiration);
   dict.SetInteger(kNumBytesKey, num_bytes);
   SetTimeValue(dict, kExpirationTimeKey, metadata.expiration_time);
-  base::JSONWriter::Write(&dict, str);
+  base::JSONWriter::Write(dict, str);
 }
 
 base::FilePath LogoCache::GetLogoPath() {
diff --git a/components/search_provider_logos/logo_tracker_unittest.cc b/components/search_provider_logos/logo_tracker_unittest.cc
index 590985a..fcd4653 100644
--- a/components/search_provider_logos/logo_tracker_unittest.cc
+++ b/components/search_provider_logos/logo_tracker_unittest.cc
@@ -139,7 +139,7 @@ std::string MakeServerResponse(
                     static_cast<int>(time_to_live.InMilliseconds()));
 
   std::string output;
-  base::JSONWriter::Write(&dict, &output);
+  base::JSONWriter::Write(dict, &output);
   return output;
 }
 
diff --git a/components/webcrypto/jwk.cc b/components/webcrypto/jwk.cc
index 4e1781d..8a9ad74 100644
--- a/components/webcrypto/jwk.cc
+++ b/components/webcrypto/jwk.cc
@@ -369,7 +369,7 @@ void JwkWriter::SetBytes(const std::string& member_name,
 
 void JwkWriter::ToJson(std::vector<uint8_t>* utf8_bytes) const {
   std::string json;
-  base::JSONWriter::Write(&dict_, &json);
+  base::JSONWriter::Write(dict_, &json);
   utf8_bytes->assign(json.begin(), json.end());
 }
 
diff --git a/components/webcrypto/test/test_helpers.cc b/components/webcrypto/test/test_helpers.cc
index 76da7fa..8e24c95 100644
--- a/components/webcrypto/test/test_helpers.cc
+++ b/components/webcrypto/test/test_helpers.cc
@@ -168,7 +168,7 @@ std::vector<uint8_t> MakeJsonVector(const std::string& json_string) {
 
 std::vector<uint8_t> MakeJsonVector(const base::DictionaryValue& dict) {
   std::string json;
-  base::JSONWriter::Write(&dict, &json);
+  base::JSONWriter::Write(dict, &json);
   return MakeJsonVector(json);
 }
 
diff --git a/content/browser/accessibility/accessibility_tree_formatter_mac.mm b/content/browser/accessibility/accessibility_tree_formatter_mac.mm
index 7b99225..b3799a9 100644
--- a/content/browser/accessibility/accessibility_tree_formatter_mac.mm
+++ b/content/browser/accessibility/accessibility_tree_formatter_mac.mm
@@ -267,7 +267,7 @@ base::string16 AccessibilityTreeFormatter::ToString(
     const base::Value* value;
     if (dict.Get(requestedAttributeUTF8, &value)) {
       std::string json_value;
-      base::JSONWriter::Write(value, &json_value);
+      base::JSONWriter::Write(*value, &json_value);
       WriteAttribute(
           [defaultAttributes containsObject:requestedAttribute],
           StringPrintf("%s=%s",
diff --git a/content/browser/accessibility/accessibility_ui.cc b/content/browser/accessibility/accessibility_ui.cc
index 3bfa6ee6..1a46646 100644
--- a/content/browser/accessibility/accessibility_ui.cc
+++ b/content/browser/accessibility/accessibility_ui.cc
@@ -116,14 +116,14 @@ bool HandleRequestCallback(BrowserContext* current_context,
     rvh_list->Append(BuildTargetDescriptor(rvh));
   }
 
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
-  data->Set("list", rvh_list.release());
-  data->SetInteger(
+  base::DictionaryValue data;
+  data.Set("list", rvh_list.release());
+  data.SetInteger(
       "global_a11y_mode",
       BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode());
 
   std::string json_string;
-  base::JSONWriter::Write(data.get(), &json_string);
+  base::JSONWriter::Write(data, &json_string);
 
   callback.Run(base::RefCountedString::TakeString(&json_string));
   return true;
diff --git a/content/browser/android/tracing_controller_android.cc b/content/browser/android/tracing_controller_android.cc
index 6953a0d..5c14535 100644
--- a/content/browser/android/tracing_controller_android.cc
+++ b/content/browser/android/tracing_controller_android.cc
@@ -91,14 +91,14 @@ bool TracingControllerAndroid::GetKnownCategoryGroupsAsync(JNIEnv* env,
 
 void TracingControllerAndroid::OnKnownCategoriesReceived(
     const std::set<std::string>& categories_received) {
-  scoped_ptr<base::ListValue> category_list(new base::ListValue());
+  base::ListValue category_list;
   for (std::set<std::string>::const_iterator it = categories_received.begin();
        it != categories_received.end();
        ++it) {
-    category_list->AppendString(*it);
+    category_list.AppendString(*it);
   }
   std::string received_category_list;
-  base::JSONWriter::Write(category_list.get(), &received_category_list);
+  base::JSONWriter::Write(category_list, &received_category_list);
 
   // This log is required by adb_profile_chrome.py.
   LOG(WARNING) << "{\"traceCategoriesList\": " << received_category_list << "}";
diff --git a/content/browser/devtools/devtools_agent_host_impl.cc b/content/browser/devtools/devtools_agent_host_impl.cc
index cba575e..4ccb496 100644
--- a/content/browser/devtools/devtools_agent_host_impl.cc
+++ b/content/browser/devtools/devtools_agent_host_impl.cc
@@ -242,7 +242,7 @@ bool DevToolsAgentHostImpl::DispatchProtocolMessage(
         delegate->HandleCommand(this, command.get()));
     if (response) {
       std::string json_response;
-      base::JSONWriter::Write(response.get(), &json_response);
+      base::JSONWriter::Write(*response, &json_response);
       SendMessageToClient(json_response);
       return true;
     }
diff --git a/content/browser/devtools/protocol/devtools_protocol_browsertest.cc b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
index cbae682..573aca4 100644
--- a/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
+++ b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
@@ -39,7 +39,7 @@ class DevToolsProtocolTest : public ContentBrowserTest,
       command.Set(kParamsParam, params.release());
 
     std::string json_command;
-    base::JSONWriter::Write(&command, &json_command);
+    base::JSONWriter::Write(command, &json_command);
     agent_host_->DispatchProtocolMessage(json_command);
     base::MessageLoop::current()->Run();
   }
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc
index 4658b08..4b7c25d 100644
--- a/content/browser/devtools/protocol/devtools_protocol_client.cc
+++ b/content/browser/devtools/protocol/devtools_protocol_client.cc
@@ -46,7 +46,7 @@ void DevToolsProtocolClient::SendRawMessage(const std::string& message) {
 
 void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) {
   std::string json_message;
-  base::JSONWriter::Write(&message, &json_message);
+  base::JSONWriter::Write(message, &json_message);
   SendRawMessage(json_message);
 }
 
diff --git a/content/browser/geolocation/network_location_provider_unittest.cc b/content/browser/geolocation/network_location_provider_unittest.cc
index b8ef6ca..cc43330 100644
--- a/content/browser/geolocation/network_location_provider_unittest.cc
+++ b/content/browser/geolocation/network_location_provider_unittest.cc
@@ -191,7 +191,7 @@ class GeolocationNetworkProviderTest : public testing::Test {
   static std::string PrettyJson(const base::Value& value) {
     std::string pretty;
     base::JSONWriter::WriteWithOptions(
-        &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty);
+        value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty);
     return pretty;
   }
 
diff --git a/content/browser/geolocation/network_location_request.cc b/content/browser/geolocation/network_location_request.cc
index 253e321..2a6c17c 100644
--- a/content/browser/geolocation/network_location_request.cc
+++ b/content/browser/geolocation/network_location_request.cc
@@ -221,7 +221,7 @@ void FormUploadData(const WifiData& wifi_data,
   AddWifiData(wifi_data, age, &request);
   if (!access_token.empty())
     request.SetString(kAccessTokenString, access_token);
-  base::JSONWriter::Write(&request, upload_data);
+  base::JSONWriter::Write(request, upload_data);
 }
 
 void AddString(const std::string& property_name, const std::string& value,
diff --git a/content/browser/indexed_db/indexed_db_backing_store.cc b/content/browser/indexed_db/indexed_db_backing_store.cc
index 79ab192..819aba5 100644
--- a/content/browser/indexed_db/indexed_db_backing_store.cc
+++ b/content/browser/indexed_db/indexed_db_backing_store.cc
@@ -958,7 +958,7 @@ bool IndexedDBBackingStore::RecordCorruptionInfo(
   base::DictionaryValue root_dict;
   root_dict.SetString("message", message);
   std::string output_js;
-  base::JSONWriter::Write(&root_dict, &output_js);
+  base::JSONWriter::Write(root_dict, &output_js);
 
   base::File file(info_path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
diff --git a/content/browser/tracing/tracing_ui.cc b/content/browser/tracing/tracing_ui.cc
index 58fbb75..546fd74 100644
--- a/content/browser/tracing/tracing_ui.cc
+++ b/content/browser/tracing/tracing_ui.cc
@@ -40,14 +40,14 @@ namespace {
 
 void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
                      const std::set<std::string>& categorySet) {
-  scoped_ptr<base::ListValue> category_list(new base::ListValue());
+  base::ListValue category_list;
   for (std::set<std::string>::const_iterator it = categorySet.begin();
        it != categorySet.end(); it++) {
-    category_list->AppendString(*it);
+    category_list.AppendString(*it);
   }
 
   base::RefCountedString* res = new base::RefCountedString();
-  base::JSONWriter::Write(category_list.get(), &res->data());
+  base::JSONWriter::Write(category_list, &res->data());
   callback.Run(res);
 }
 
@@ -133,12 +133,12 @@ void OnTraceBufferUsageResult(const WebUIDataSource::GotDataCallback& callback,
 void OnTraceBufferStatusResult(const WebUIDataSource::GotDataCallback& callback,
                                float percent_full,
                                size_t approximate_event_count) {
-  scoped_ptr<base::DictionaryValue> status(new base::DictionaryValue());
-  status->SetDouble("percentFull", percent_full);
-  status->SetInteger("approximateEventCount", approximate_event_count);
+  base::DictionaryValue status;
+  status.SetDouble("percentFull", percent_full);
+  status.SetInteger("approximateEventCount", approximate_event_count);
 
   std::string status_json;
-  base::JSONWriter::Write(status.get(), &status_json);
+  base::JSONWriter::Write(status, &status_json);
 
   base::RefCountedString* status_base64 = new base::RefCountedString();
   base::Base64Encode(status_json, &status_base64->data());
@@ -177,18 +177,17 @@ void GetMonitoringStatus(const WebUIDataSource::GotDataCallback& callback) {
   TracingController::GetInstance()->GetMonitoringStatus(
       &is_monitoring, &category_filter, &options);
 
-  scoped_ptr<base::DictionaryValue>
-    monitoring_options(new base::DictionaryValue());
-  monitoring_options->SetBoolean("isMonitoring", is_monitoring);
-  monitoring_options->SetString("categoryFilter", category_filter.ToString());
-  monitoring_options->SetBoolean("useSystemTracing", options.enable_systrace);
-  monitoring_options->SetBoolean(
+  base::DictionaryValue monitoring_options;
+  monitoring_options.SetBoolean("isMonitoring", is_monitoring);
+  monitoring_options.SetString("categoryFilter", category_filter.ToString());
+  monitoring_options.SetBoolean("useSystemTracing", options.enable_systrace);
+  monitoring_options.SetBoolean(
       "useContinuousTracing",
       options.record_mode == base::trace_event::RECORD_CONTINUOUSLY);
-  monitoring_options->SetBoolean("useSampling", options.enable_sampling);
+  monitoring_options.SetBoolean("useSampling", options.enable_sampling);
 
   std::string monitoring_options_json;
-  base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
+  base::JSONWriter::Write(monitoring_options, &monitoring_options_json);
 
   base::RefCountedString* monitoring_options_base64 =
     new base::RefCountedString();
diff --git a/content/browser/web_contents/web_contents_android.cc b/content/browser/web_contents/web_contents_android.cc
index 7600035..dc23623 100644
--- a/content/browser/web_contents/web_contents_android.cc
+++ b/content/browser/web_contents/web_contents_android.cc
@@ -46,7 +46,7 @@ void JavaScriptResultCallback(const ScopedJavaGlobalRef<jobject>& callback,
                               const base::Value* result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   std::string json;
-  base::JSONWriter::Write(result, &json);
+  base::JSONWriter::Write(*result, &json);
   ScopedJavaLocalRef<jstring> j_json = ConvertUTF8ToJavaString(env, json);
   Java_WebContentsImpl_onEvaluateJavaScriptResult(
       env, j_json.obj(), callback.obj());
diff --git a/content/browser/webui/web_ui_impl.cc b/content/browser/webui/web_ui_impl.cc
index a9194a9..1f953a2 100644
--- a/content/browser/webui/web_ui_impl.cc
+++ b/content/browser/webui/web_ui_impl.cc
@@ -36,7 +36,7 @@ base::string16 WebUI::GetJavascriptCall(
     if (i > 0)
       parameters += base::char16(',');
 
-    base::JSONWriter::Write(arg_list[i], &json);
+    base::JSONWriter::Write(*arg_list[i], &json);
     parameters += base::UTF8ToUTF16(json);
   }
   return base::ASCIIToUTF16(function_name) +
diff --git a/content/common/gpu/gpu_command_buffer_stub.cc b/content/common/gpu/gpu_command_buffer_stub.cc
index 5c878fc..bb4044a 100644
--- a/content/common/gpu/gpu_command_buffer_stub.cc
+++ b/content/common/gpu/gpu_command_buffer_stub.cc
@@ -118,7 +118,7 @@ class DevToolsChannelData : public base::trace_event::ConvertableToTraceFormat {
 
   void AppendAsTraceFormat(std::string* out) const override {
     std::string tmp;
-    base::JSONWriter::Write(value_.get(), &tmp);
+    base::JSONWriter::Write(*value_, &tmp);
     *out += tmp;
   }
 
diff --git a/content/renderer/stats_collection_controller.cc b/content/renderer/stats_collection_controller.cc
index 6f42a02..9cbdab2 100644
--- a/content/renderer/stats_collection_controller.cc
+++ b/content/renderer/stats_collection_controller.cc
@@ -66,7 +66,7 @@ void ConvertLoadTimeToJSON(
     item.SetDouble("load_duration_ms",
         (load_stop_time - load_start_time).InMillisecondsF());
   }
-  base::JSONWriter::Write(&item, result);
+  base::JSONWriter::Write(item, result);
 }
 
 }  // namespace
diff --git a/content/shell/browser/shell_devtools_frontend.cc b/content/shell/browser/shell_devtools_frontend.cc
index 0cd1c93..2ad0c2e 100644
--- a/content/shell/browser/shell_devtools_frontend.cc
+++ b/content/shell/browser/shell_devtools_frontend.cc
@@ -267,9 +267,9 @@ void ShellDevToolsFrontend::DispatchProtocolMessage(
 
   base::FundamentalValue total_size(static_cast<int>(message.length()));
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
-    base::StringValue message_value(message.substr(pos, kMaxMessageChunkSize));
     std::string param;
-    base::JSONWriter::Write(&message_value, &param);
+    base::JSONWriter::Write(
+        base::StringValue(message.substr(pos, kMaxMessageChunkSize)), &param);
     std::string code = "DevToolsAPI.dispatchMessageChunk(" + param + ");";
     base::string16 javascript = base::UTF8ToUTF16(code);
     web_contents()->GetMainFrame()->ExecuteJavaScript(javascript);
@@ -308,13 +308,13 @@ void ShellDevToolsFrontend::CallClientFunction(
   std::string javascript = function_name + "(";
   if (arg1) {
     std::string json;
-    base::JSONWriter::Write(arg1, &json);
+    base::JSONWriter::Write(*arg1, &json);
     javascript.append(json);
     if (arg2) {
-      base::JSONWriter::Write(arg2, &json);
+      base::JSONWriter::Write(*arg2, &json);
       javascript.append(", ").append(json);
       if (arg3) {
-        base::JSONWriter::Write(arg3, &json);
+        base::JSONWriter::Write(*arg3, &json);
         javascript.append(", ").append(json);
       }
     }
diff --git a/content/shell/renderer/layout_test/leak_detector.cc b/content/shell/renderer/layout_test/leak_detector.cc
index a00fdba..41645bb 100644
--- a/content/shell/renderer/layout_test/leak_detector.cc
+++ b/content/shell/renderer/layout_test/leak_detector.cc
@@ -85,7 +85,7 @@ void LeakDetector::onLeakDetectionComplete(
 
   if (!detail.empty()) {
     std::string detail_str;
-    base::JSONWriter::Write(&detail, &detail_str);
+    base::JSONWriter::Write(detail, &detail_str);
     report.detail = detail_str;
     report.leaked = true;
   }
diff --git a/content/shell/renderer/test_runner/test_interfaces.cc b/content/shell/renderer/test_runner/test_interfaces.cc
index fda7974..2dd3e41 100644
--- a/content/shell/renderer/test_runner/test_interfaces.cc
+++ b/content/shell/renderer/test_runner/test_interfaces.cc
@@ -119,7 +119,7 @@ void TestInterfaces::ConfigureForTestWithURL(const blink::WebURL& test_url,
     base::DictionaryValue settings;
     settings.SetString("testPath", base::GetQuotedJSONString(spec));
     std::string settings_string;
-    base::JSONWriter::Write(&settings, &settings_string);
+    base::JSONWriter::Write(settings, &settings_string);
     test_runner_->ShowDevTools(settings_string, std::string());
   }
   if (spec.find("/viewsource/") != std::string::npos) {
diff --git a/dbus/values_util.cc b/dbus/values_util.cc
index c27c272..c162878 100644
--- a/dbus/values_util.cc
+++ b/dbus/values_util.cc
@@ -48,10 +48,10 @@ bool PopDictionaryEntries(MessageReader* reader,
     } else {
       // If the type of keys is not STRING, convert it to string.
       scoped_ptr<base::Value> key(PopDataAsValue(&entry_reader));
-      if (!key.get())
+      if (!key)
         return false;
       // Use JSONWriter to convert an arbitrary value to a string.
-      base::JSONWriter::Write(key.get(), &key_string);
+      base::JSONWriter::Write(*key, &key_string);
     }
     // Get the value and set the key-value pair.
     base::Value* value = PopDataAsValue(&entry_reader);
diff --git a/dbus/values_util_unittest.cc b/dbus/values_util_unittest.cc
index 27ec2d0..6abc56a 100644
--- a/dbus/values_util_unittest.cc
+++ b/dbus/values_util_unittest.cc
@@ -377,11 +377,9 @@ TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
   // Create the expected value.
   base::DictionaryValue dictionary_value;
   for (size_t i = 0; i != values.size(); ++i) {
-    scoped_ptr<base::Value> key_value(new base::FundamentalValue(keys[i]));
     std::string key_string;
-    base::JSONWriter::Write(key_value.get(), &key_string);
-    dictionary_value.SetWithoutPathExpansion(
-        key_string, new base::FundamentalValue(values[i]));
+    base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string);
+    dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]);
   }
 
   // Pop a dictionary.
diff --git a/extensions/browser/api/cast_channel/cast_channel_api.cc b/extensions/browser/api/cast_channel/cast_channel_api.cc
index e00646e..4ad8624 100644
--- a/extensions/browser/api/cast_channel/cast_channel_api.cc
+++ b/extensions/browser/api/cast_channel/cast_channel_api.cc
@@ -59,7 +59,7 @@ template <class T>
 std::string ParamToString(const T& info) {
   scoped_ptr<base::DictionaryValue> dict = info.ToValue();
   std::string out;
-  base::JSONWriter::Write(dict.get(), &out);
+  base::JSONWriter::Write(*dict, &out);
   return out;
 }
 
diff --git a/extensions/browser/api/cast_channel/keep_alive_delegate.cc b/extensions/browser/api/cast_channel/keep_alive_delegate.cc
index 73c356f4..df23519 100644
--- a/extensions/browser/api/cast_channel/keep_alive_delegate.cc
+++ b/extensions/browser/api/cast_channel/keep_alive_delegate.cc
@@ -68,7 +68,7 @@ CastMessage KeepAliveDelegate::CreateKeepAliveMessage(
   output.set_namespace_(kHeartbeatNamespace);
   base::DictionaryValue type_dict;
   type_dict.SetString(kTypeNodeId, message_type);
-  if (!base::JSONWriter::Write(&type_dict, output.mutable_payload_utf8())) {
+  if (!base::JSONWriter::Write(type_dict, output.mutable_payload_utf8())) {
     LOG(ERROR) << "Failed to serialize dictionary.";
     return output;
   }
diff --git a/extensions/browser/api/storage/settings_quota_unittest.cc b/extensions/browser/api/storage/settings_quota_unittest.cc
index 391043e..02e8735 100644
--- a/extensions/browser/api/storage/settings_quota_unittest.cc
+++ b/extensions/browser/api/storage/settings_quota_unittest.cc
@@ -24,23 +24,22 @@ const ValueStore::WriteOptions IGNORE_QUOTA =
 class ExtensionSettingsQuotaTest : public testing::Test {
  public:
   ExtensionSettingsQuotaTest()
-      : byte_value_1_(new base::FundamentalValue(1)),
-        byte_value_16_(new base::StringValue("sixteen bytes.")),
-        byte_value_256_(new base::ListValue()),
+      : byte_value_1_(1),
+        byte_value_16_("sixteen bytes."),
         delegate_(new TestingValueStore()) {
     for (int i = 1; i < 89; ++i) {
-      byte_value_256_->Append(new base::FundamentalValue(i));
+      byte_value_256_.AppendInteger(i);
     }
     ValidateByteValues();
   }
 
   void ValidateByteValues() {
     std::string validate_sizes;
-    base::JSONWriter::Write(byte_value_1_.get(), &validate_sizes);
+    base::JSONWriter::Write(byte_value_1_, &validate_sizes);
     ASSERT_EQ(1u, validate_sizes.size());
-    base::JSONWriter::Write(byte_value_16_.get(), &validate_sizes);
+    base::JSONWriter::Write(byte_value_16_, &validate_sizes);
     ASSERT_EQ(16u, validate_sizes.size());
-    base::JSONWriter::Write(byte_value_256_.get(), &validate_sizes);
+    base::JSONWriter::Write(byte_value_256_, &validate_sizes);
     ASSERT_EQ(256u, validate_sizes.size());
   }
 
@@ -64,9 +63,9 @@ class ExtensionSettingsQuotaTest : public testing::Test {
   }
 
   // Values with different serialized sizes.
-  scoped_ptr<base::Value> byte_value_1_;
-  scoped_ptr<base::Value> byte_value_16_;
-  scoped_ptr<base::ListValue> byte_value_256_;
+  base::FundamentalValue byte_value_1_;
+  base::StringValue byte_value_16_;
+  base::ListValue byte_value_256_;
 
   // Quota enforcing storage area being tested.
   scoped_ptr<SettingsStorageQuotaEnforcer> storage_;
@@ -79,7 +78,7 @@ TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytes) {
   base::DictionaryValue empty;
   CreateStorage(0, UINT_MAX, UINT_MAX);
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_FALSE(storage_->Remove("a")->HasError());
   EXPECT_FALSE(storage_->Remove("b")->HasError());
   EXPECT_TRUE(SettingsEqual(empty));
@@ -89,7 +88,7 @@ TEST_F(ExtensionSettingsQuotaTest, KeySizeTakenIntoAccount) {
   base::DictionaryValue empty;
   CreateStorage(8u, UINT_MAX, UINT_MAX);
   EXPECT_TRUE(
-      storage_->Set(DEFAULTS, "Really long key", *byte_value_1_)->HasError());
+      storage_->Set(DEFAULTS, "Really long key", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(empty));
 }
 
@@ -97,12 +96,12 @@ TEST_F(ExtensionSettingsQuotaTest, SmallByteQuota) {
   base::DictionaryValue settings;
   CreateStorage(8u, UINT_MAX, UINT_MAX);
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -111,20 +110,20 @@ TEST_F(ExtensionSettingsQuotaTest, MediumByteQuota) {
   CreateStorage(40, UINT_MAX, UINT_MAX);
 
   base::DictionaryValue to_set;
-  to_set.Set("a", byte_value_1_->DeepCopy());
-  to_set.Set("b", byte_value_16_->DeepCopy());
+  to_set.Set("a", byte_value_1_.CreateDeepCopy());
+  to_set.Set("b", byte_value_16_.CreateDeepCopy());
   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
-  settings.Set("b", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Should be able to set value to other under-quota value.
-  to_set.Set("a", byte_value_16_->DeepCopy());
+  to_set.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -132,7 +131,7 @@ TEST_F(ExtensionSettingsQuotaTest, ZeroMaxKeys) {
   base::DictionaryValue empty;
   CreateStorage(UINT_MAX, UINT_MAX, 0);
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_FALSE(storage_->Remove("a")->HasError());
   EXPECT_FALSE(storage_->Remove("b")->HasError());
   EXPECT_TRUE(SettingsEqual(empty));
@@ -142,17 +141,17 @@ TEST_F(ExtensionSettingsQuotaTest, SmallMaxKeys) {
   base::DictionaryValue settings;
   CreateStorage(UINT_MAX, UINT_MAX, 1);
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Should be able to set existing key to other value without going over quota.
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_16_)->HasError());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -161,21 +160,21 @@ TEST_F(ExtensionSettingsQuotaTest, MediumMaxKeys) {
   CreateStorage(UINT_MAX, UINT_MAX, 2);
 
   base::DictionaryValue to_set;
-  to_set.Set("a", byte_value_1_->DeepCopy());
-  to_set.Set("b", byte_value_16_->DeepCopy());
+  to_set.Set("a", byte_value_1_.CreateDeepCopy());
+  to_set.Set("b", byte_value_16_.CreateDeepCopy());
   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
-  settings.Set("b", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Should be able to set existing keys to other values without going over
   // quota.
-  to_set.Set("a", byte_value_16_->DeepCopy());
+  to_set.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -183,32 +182,32 @@ TEST_F(ExtensionSettingsQuotaTest, RemovingExistingSettings) {
   base::DictionaryValue settings;
   CreateStorage(266, UINT_MAX, 2);
 
-  storage_->Set(DEFAULTS, "b", *byte_value_16_);
-  settings.Set("b", byte_value_16_->DeepCopy());
+  storage_->Set(DEFAULTS, "b", byte_value_16_);
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
   // Not enough quota.
-  storage_->Set(DEFAULTS, "c", *byte_value_256_);
+  storage_->Set(DEFAULTS, "c", byte_value_256_);
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Try again with "b" removed, enough quota.
   EXPECT_FALSE(storage_->Remove("b")->HasError());
   settings.Remove("b", NULL);
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
-  settings.Set("c", byte_value_256_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
+  settings.Set("c", byte_value_256_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Enough byte quota but max keys not high enough.
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Back under max keys.
   EXPECT_FALSE(storage_->Remove("a")->HasError());
   settings.Remove("a", NULL);
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
-  settings.Set("b", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_1_)->HasError());
+  settings.Set("b", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -218,12 +217,12 @@ TEST_F(ExtensionSettingsQuotaTest, RemovingNonexistentSettings) {
 
   // Max out bytes.
   base::DictionaryValue to_set;
-  to_set.Set("b1", byte_value_16_->DeepCopy());
-  to_set.Set("b2", byte_value_16_->DeepCopy());
+  to_set.Set("b1", byte_value_16_.CreateDeepCopy());
+  to_set.Set("b2", byte_value_16_.CreateDeepCopy());
   storage_->Set(DEFAULTS, to_set);
-  settings.Set("b1", byte_value_16_->DeepCopy());
-  settings.Set("b2", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  settings.Set("b1", byte_value_16_.CreateDeepCopy());
+  settings.Set("b2", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Remove some settings that don't exist.
@@ -235,18 +234,18 @@ TEST_F(ExtensionSettingsQuotaTest, RemovingNonexistentSettings) {
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Still no quota.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Max out key count.
   to_set.Clear();
-  to_set.Set("b1", byte_value_1_->DeepCopy());
-  to_set.Set("b2", byte_value_1_->DeepCopy());
+  to_set.Set("b1", byte_value_1_.CreateDeepCopy());
+  to_set.Set("b2", byte_value_1_.CreateDeepCopy());
   storage_->Set(DEFAULTS, to_set);
-  settings.Set("b1", byte_value_1_->DeepCopy());
-  settings.Set("b2", byte_value_1_->DeepCopy());
-  storage_->Set(DEFAULTS, "b3", *byte_value_1_);
-  settings.Set("b3", byte_value_1_->DeepCopy());
+  settings.Set("b1", byte_value_1_.CreateDeepCopy());
+  settings.Set("b2", byte_value_1_.CreateDeepCopy());
+  storage_->Set(DEFAULTS, "b3", byte_value_1_);
+  settings.Set("b3", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Remove some settings that don't exist.
@@ -258,7 +257,7 @@ TEST_F(ExtensionSettingsQuotaTest, RemovingNonexistentSettings) {
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Still no quota.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -269,35 +268,35 @@ TEST_F(ExtensionSettingsQuotaTest, Clear) {
   // Test running out of byte quota.
   {
     base::DictionaryValue to_set;
-    to_set.Set("a", byte_value_16_->DeepCopy());
-    to_set.Set("b", byte_value_16_->DeepCopy());
+    to_set.Set("a", byte_value_16_.CreateDeepCopy());
+    to_set.Set("b", byte_value_16_.CreateDeepCopy());
     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-    EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
+    EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_16_)->HasError());
 
     EXPECT_FALSE(storage_->Clear()->HasError());
 
     // (repeat)
     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-    EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
+    EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_16_)->HasError());
   }
 
   // Test reaching max keys.
   storage_->Clear();
   {
     base::DictionaryValue to_set;
-    to_set.Set("a", byte_value_1_->DeepCopy());
-    to_set.Set("b", byte_value_1_->DeepCopy());
-    to_set.Set("c", byte_value_1_->DeepCopy());
-    to_set.Set("d", byte_value_1_->DeepCopy());
-    to_set.Set("e", byte_value_1_->DeepCopy());
+    to_set.Set("a", byte_value_1_.CreateDeepCopy());
+    to_set.Set("b", byte_value_1_.CreateDeepCopy());
+    to_set.Set("c", byte_value_1_.CreateDeepCopy());
+    to_set.Set("d", byte_value_1_.CreateDeepCopy());
+    to_set.Set("e", byte_value_1_.CreateDeepCopy());
     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-    EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
+    EXPECT_TRUE(storage_->Set(DEFAULTS, "f", byte_value_1_)->HasError());
 
     storage_->Clear();
 
     // (repeat)
     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-    EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
+    EXPECT_TRUE(storage_->Set(DEFAULTS, "f", byte_value_1_)->HasError());
   }
 }
 
@@ -306,20 +305,20 @@ TEST_F(ExtensionSettingsQuotaTest, ChangingUsedBytesWithSet) {
   CreateStorage(20, UINT_MAX, UINT_MAX);
 
   // Change a setting to make it go over quota.
-  storage_->Set(DEFAULTS, "a", *byte_value_16_);
-  settings.Set("a", byte_value_16_->DeepCopy());
+  storage_->Set(DEFAULTS, "a", byte_value_16_);
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_256_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Change a setting to reduce usage and room for another setting.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
-  storage_->Set(DEFAULTS, "a", *byte_value_1_);
-  settings.Set("a", byte_value_1_->DeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "foobar", byte_value_1_)->HasError());
+  storage_->Set(DEFAULTS, "a", byte_value_1_);
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
-  settings.Set("foobar", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "foobar", byte_value_1_)->HasError());
+  settings.Set("foobar", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -327,22 +326,22 @@ TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntirelyCompletedWithByteQuota) {
   base::DictionaryValue settings;
   CreateStorage(40, UINT_MAX, UINT_MAX);
 
-  storage_->Set(DEFAULTS, "a", *byte_value_16_);
-  settings.Set("a", byte_value_16_->DeepCopy());
+  storage_->Set(DEFAULTS, "a", byte_value_16_);
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
 
   // The entire change is over quota.
   base::DictionaryValue to_set;
-  to_set.Set("b", byte_value_16_->DeepCopy());
-  to_set.Set("c", byte_value_16_->DeepCopy());
+  to_set.Set("b", byte_value_16_.CreateDeepCopy());
+  to_set.Set("c", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // The entire change is over quota, but quota reduced in existing key.
-  to_set.Set("a", byte_value_1_->DeepCopy());
+  to_set.Set("a", byte_value_1_.CreateDeepCopy());
   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
-  settings.Set("b", byte_value_16_->DeepCopy());
-  settings.Set("c", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -350,44 +349,44 @@ TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntireCompletedWithMaxKeys) {
   base::DictionaryValue settings;
   CreateStorage(UINT_MAX, UINT_MAX, 2);
 
-  storage_->Set(DEFAULTS, "a", *byte_value_1_);
-  settings.Set("a", byte_value_1_->DeepCopy());
+  storage_->Set(DEFAULTS, "a", byte_value_1_);
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
 
   base::DictionaryValue to_set;
-  to_set.Set("b", byte_value_16_->DeepCopy());
-  to_set.Set("c", byte_value_16_->DeepCopy());
+  to_set.Set("b", byte_value_16_.CreateDeepCopy());
+  to_set.Set("c", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndByteQuota) {
   base::DictionaryValue settings;
-  delegate_->Set(DEFAULTS, "a", *byte_value_256_);
-  settings.Set("a", byte_value_256_->DeepCopy());
+  delegate_->Set(DEFAULTS, "a", byte_value_256_);
+  settings.Set("a", byte_value_256_.CreateDeepCopy());
 
   CreateStorage(280, UINT_MAX, UINT_MAX);
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Add some data.
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
-  settings.Set("b", byte_value_16_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_16_)->HasError());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Not enough quota.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_16_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Reduce usage of original setting so that "c" can fit.
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_16_)->HasError());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
-  settings.Set("c", byte_value_16_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", byte_value_16_)->HasError());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Remove to free up some more data.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", byte_value_256_)->HasError());
 
   std::vector<std::string> to_remove;
   to_remove.push_back("a");
@@ -397,61 +396,61 @@ TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndByteQuota) {
   settings.Remove("b", NULL);
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
-  settings.Set("d", byte_value_256_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "d", byte_value_256_)->HasError());
+  settings.Set("d", byte_value_256_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndMaxKeys) {
   base::DictionaryValue settings;
-  delegate_->Set(DEFAULTS, "a", *byte_value_1_);
-  settings.Set("a", byte_value_1_->DeepCopy());
+  delegate_->Set(DEFAULTS, "a", byte_value_1_);
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
   CreateStorage(UINT_MAX, UINT_MAX, 2);
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
-  settings.Set("b", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_1_)->HasError());
+  settings.Set("b", byte_value_1_.CreateDeepCopy());
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_1_)->HasError());
 
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverByteQuota) {
   base::DictionaryValue settings;
-  settings.Set("a", byte_value_16_->DeepCopy());
-  settings.Set("b", byte_value_16_->DeepCopy());
-  settings.Set("c", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
   delegate_->Set(DEFAULTS, settings);
 
   CreateStorage(40, UINT_MAX, UINT_MAX);
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", byte_value_16_)->HasError());
 
   // Take under quota by reducing size of an existing setting
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  settings.Set("a", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  settings.Set("a", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Should be able set another small setting.
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_1_)->HasError());
-  settings.Set("d", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "d", byte_value_1_)->HasError());
+  settings.Set("d", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverMaxKeys) {
   base::DictionaryValue settings;
-  settings.Set("a", byte_value_16_->DeepCopy());
-  settings.Set("b", byte_value_16_->DeepCopy());
-  settings.Set("c", byte_value_16_->DeepCopy());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
   delegate_->Set(DEFAULTS, settings);
 
   CreateStorage(UINT_MAX, UINT_MAX, 2);
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Can't set either an existing or new setting.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Should be able after removing 2.
@@ -461,13 +460,13 @@ TEST_F(ExtensionSettingsQuotaTest, InitiallyOverMaxKeys) {
   settings.Remove("b", NULL);
   EXPECT_TRUE(SettingsEqual(settings));
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "e", *byte_value_1_)->HasError());
-  settings.Set("e", byte_value_1_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "e", byte_value_1_)->HasError());
+  settings.Set("e", byte_value_1_.CreateDeepCopy());
   EXPECT_TRUE(SettingsEqual(settings));
 
   // Still can't set any.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "d", byte_value_16_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_TRUE(SettingsEqual(settings));
 }
 
@@ -475,7 +474,7 @@ TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytesPerSetting) {
   base::DictionaryValue empty;
   CreateStorage(UINT_MAX, 0, UINT_MAX);
 
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
   EXPECT_FALSE(storage_->Remove("a")->HasError());
   EXPECT_FALSE(storage_->Remove("b")->HasError());
   EXPECT_TRUE(SettingsEqual(empty));
@@ -486,15 +485,15 @@ TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSetting) {
 
   CreateStorage(UINT_MAX, 20, UINT_MAX);
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_16_)->HasError());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_256_)->HasError());
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
-  settings.Set("b", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_16_)->HasError());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", byte_value_256_)->HasError());
 
   EXPECT_TRUE(SettingsEqual(settings));
 }
@@ -502,25 +501,25 @@ TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSetting) {
 TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSettingWithInitialSettings) {
   base::DictionaryValue settings;
 
-  delegate_->Set(DEFAULTS, "a", *byte_value_1_);
-  delegate_->Set(DEFAULTS, "b", *byte_value_16_);
-  delegate_->Set(DEFAULTS, "c", *byte_value_256_);
+  delegate_->Set(DEFAULTS, "a", byte_value_1_);
+  delegate_->Set(DEFAULTS, "b", byte_value_16_);
+  delegate_->Set(DEFAULTS, "c", byte_value_256_);
   CreateStorage(UINT_MAX, 20, UINT_MAX);
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
-  settings.Set("a", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "a", byte_value_16_)->HasError());
+  settings.Set("a", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "a", byte_value_256_)->HasError());
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
-  settings.Set("b", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "b", byte_value_16_)->HasError());
+  settings.Set("b", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "b", byte_value_256_)->HasError());
 
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
-  settings.Set("c", byte_value_16_->DeepCopy());
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(DEFAULTS, "c", byte_value_16_)->HasError());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
 
   EXPECT_TRUE(SettingsEqual(settings));
 }
@@ -532,27 +531,27 @@ TEST_F(ExtensionSettingsQuotaTest,
   // rejected...
   base::DictionaryValue settings;
 
-  delegate_->Set(DEFAULTS, "a", *byte_value_1_);
-  delegate_->Set(DEFAULTS, "b", *byte_value_16_);
-  delegate_->Set(DEFAULTS, "c", *byte_value_256_);
+  delegate_->Set(DEFAULTS, "a", byte_value_1_);
+  delegate_->Set(DEFAULTS, "b", byte_value_16_);
+  delegate_->Set(DEFAULTS, "c", byte_value_256_);
   CreateStorage(UINT_MAX, 20, UINT_MAX);
 
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_16_)->HasError());
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_256_)->HasError());
-  settings.Set("a", byte_value_256_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", byte_value_16_)->HasError());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", byte_value_256_)->HasError());
+  settings.Set("a", byte_value_256_.CreateDeepCopy());
 
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_16_)->HasError());
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_256_)->HasError());
-  settings.Set("b", byte_value_256_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", byte_value_16_)->HasError());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", byte_value_256_)->HasError());
+  settings.Set("b", byte_value_256_.CreateDeepCopy());
 
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_1_)->HasError());
-  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_16_)->HasError());
-  settings.Set("c", byte_value_16_->DeepCopy());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", byte_value_1_)->HasError());
+  EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", byte_value_16_)->HasError());
+  settings.Set("c", byte_value_16_.CreateDeepCopy());
 
   // ... except the last.  Make sure it can still fail.
-  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
+  EXPECT_TRUE(storage_->Set(DEFAULTS, "c", byte_value_256_)->HasError());
 
   EXPECT_TRUE(SettingsEqual(settings));
 }
@@ -570,21 +569,21 @@ TEST_F(ExtensionSettingsQuotaTest, GetBytesInUse) {
   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
   EXPECT_EQ(0u, storage_->GetBytesInUse(ab));
 
-  storage_->Set(DEFAULTS, "a", *byte_value_1_);
+  storage_->Set(DEFAULTS, "a", byte_value_1_);
 
   EXPECT_EQ(2u, storage_->GetBytesInUse());
   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
   EXPECT_EQ(2u, storage_->GetBytesInUse(ab));
 
-  storage_->Set(DEFAULTS, "b", *byte_value_1_);
+  storage_->Set(DEFAULTS, "b", byte_value_1_);
 
   EXPECT_EQ(4u, storage_->GetBytesInUse());
   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
   EXPECT_EQ(2u, storage_->GetBytesInUse("b"));
   EXPECT_EQ(4u, storage_->GetBytesInUse(ab));
 
-  storage_->Set(DEFAULTS, "c", *byte_value_1_);
+  storage_->Set(DEFAULTS, "c", byte_value_1_);
 
   EXPECT_EQ(6u, storage_->GetBytesInUse());
   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
diff --git a/extensions/browser/api/storage/settings_storage_quota_enforcer.cc b/extensions/browser/api/storage/settings_storage_quota_enforcer.cc
index e448a5d..1fbcbbd 100644
--- a/extensions/browser/api/storage/settings_storage_quota_enforcer.cc
+++ b/extensions/browser/api/storage/settings_storage_quota_enforcer.cc
@@ -38,7 +38,7 @@ void Allocate(
   // TODO(kalman): This is duplicating work that the leveldb delegate
   // implementation is about to do, and it would be nice to avoid this.
   std::string value_as_json;
-  base::JSONWriter::Write(&value, &value_as_json);
+  base::JSONWriter::Write(value, &value_as_json);
   size_t new_size = key.size() + value_as_json.size();
   size_t existing_size = (*used_per_setting)[key];
 
diff --git a/extensions/browser/api/web_request/web_request_api.cc b/extensions/browser/api/web_request/web_request_api.cc
index 7de492e..f6c7527 100644
--- a/extensions/browser/api/web_request/web_request_api.cc
+++ b/extensions/browser/api/web_request/web_request_api.cc
@@ -2374,7 +2374,7 @@ bool WebRequestInternalEventHandledFunction::RunSync() {
             headers_value->GetDictionary(i, &header_value));
         if (!FromHeaderDictionary(header_value, &name, &value)) {
           std::string serialized_header;
-          base::JSONWriter::Write(header_value, &serialized_header);
+          base::JSONWriter::Write(*header_value, &serialized_header);
           RespondWithError(event_name,
                            sub_event_name,
                            request_id,
diff --git a/extensions/browser/computed_hashes.cc b/extensions/browser/computed_hashes.cc
index 473ee3c..35ea525 100644
--- a/extensions/browser/computed_hashes.cc
+++ b/extensions/browser/computed_hashes.cc
@@ -156,7 +156,7 @@ bool ComputedHashes::Writer::WriteToFile(const base::FilePath& path) {
   top_dictionary.SetInteger(kVersionKey, kVersion);
   top_dictionary.Set(kFileHashesKey, file_list_.release());
 
-  if (!base::JSONWriter::Write(&top_dictionary, &json))
+  if (!base::JSONWriter::Write(top_dictionary, &json))
     return false;
   int written = base::WriteFile(path, json.data(), json.size());
   if (static_cast<unsigned>(written) != json.size()) {
diff --git a/extensions/browser/value_store/leveldb_value_store.cc b/extensions/browser/value_store/leveldb_value_store.cc
index ad8076d..4b7d274 100644
--- a/extensions/browser/value_store/leveldb_value_store.cc
+++ b/extensions/browser/value_store/leveldb_value_store.cc
@@ -389,7 +389,7 @@ scoped_ptr<ValueStore::Error> LeveldbValueStore::AddToBatch(
 
   if (write_new_value) {
     std::string value_as_json;
-    if (!base::JSONWriter::Write(&value, &value_as_json))
+    if (!base::JSONWriter::Write(value, &value_as_json))
       return Error::Create(OTHER_ERROR, kCannotSerialize, util::NewKey(key));
     batch->Put(key, value_as_json);
   }
diff --git a/extensions/browser/value_store/value_store_change.cc b/extensions/browser/value_store/value_store_change.cc
index 822c9b9..904ec82 100644
--- a/extensions/browser/value_store/value_store_change.cc
+++ b/extensions/browser/value_store/value_store_change.cc
@@ -23,7 +23,7 @@ std::string ValueStoreChange::ToJson(
     changes_value.SetWithoutPathExpansion(it->key(), change_value);
   }
   std::string json;
-  base::JSONWriter::Write(&changes_value, &json);
+  base::JSONWriter::Write(changes_value, &json);
   return json;
 }
 
diff --git a/extensions/browser/value_store/value_store_unittest.cc b/extensions/browser/value_store/value_store_unittest.cc
index 4293459..c2ecbab 100644
--- a/extensions/browser/value_store/value_store_unittest.cc
+++ b/extensions/browser/value_store/value_store_unittest.cc
@@ -18,9 +18,8 @@ const ValueStore::WriteOptions DEFAULTS = ValueStore::DEFAULTS;
 // Gets the pretty-printed JSON for a value.
 std::string GetJSON(const base::Value& value) {
   std::string json;
-  base::JSONWriter::WriteWithOptions(&value,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
+  base::JSONWriter::WriteWithOptions(
+      value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/extensions/common/permissions/manifest_permission.cc b/extensions/common/permissions/manifest_permission.cc
index a3a3a09..6be6b18 100644
--- a/extensions/common/permissions/manifest_permission.cc
+++ b/extensions/common/permissions/manifest_permission.cc
@@ -48,7 +48,7 @@ bool ManifestPermission::Read(const IPC::Message* m, PickleIterator* iter) {
 
 void ManifestPermission::Log(std::string* log) const {
   base::JSONWriter::WriteWithOptions(
-      ToValue().get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, log);
+      *ToValue(), base::JSONWriter::OPTIONS_PRETTY_PRINT, log);
 }
 
 }  // namespace extensions
diff --git a/extensions/common/permissions/set_disjunction_permission.h b/extensions/common/permissions/set_disjunction_permission.h
index 87d1858..28b6867 100644
--- a/extensions/common/permissions/set_disjunction_permission.h
+++ b/extensions/common/permissions/set_disjunction_permission.h
@@ -122,7 +122,7 @@ class SetDisjunctionPermission : public APIPermission {
         data_set_.insert(data);
       } else {
         std::string unknown_permission;
-        base::JSONWriter::Write(item_value, &unknown_permission);
+        base::JSONWriter::Write(*item_value, &unknown_permission);
         if (unhandled_permissions) {
           unhandled_permissions->push_back(unknown_permission);
         } else {
diff --git a/extensions/common/value_builder.cc b/extensions/common/value_builder.cc
index 3d8c289..4011e70 100644
--- a/extensions/common/value_builder.cc
+++ b/extensions/common/value_builder.cc
@@ -20,7 +20,7 @@ DictionaryBuilder::~DictionaryBuilder() {}
 std::string DictionaryBuilder::ToJSON() const {
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      dict_.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      *dict_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/google_apis/drive/drive_api_requests.cc b/google_apis/drive/drive_api_requests.cc
index 5cd289a..57a3ec1 100644
--- a/google_apis/drive/drive_api_requests.cc
+++ b/google_apis/drive/drive_api_requests.cc
@@ -130,7 +130,7 @@ std::string CreateMultipartUploadMetadataJson(
 
   AttachProperties(properties, &root);
   std::string json_string;
-  base::JSONWriter::Write(&root, &json_string);
+  base::JSONWriter::Write(root, &json_string);
   return json_string;
 }
 
@@ -417,7 +417,7 @@ bool FilesInsertRequest::GetContentData(std::string* upload_content_type,
     root.SetString("title", title_);
 
   AttachProperties(properties_, &root);
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
 
   DVLOG(1) << "FilesInsert data: " << *upload_content_type << ", ["
            << *upload_content << "]";
@@ -491,7 +491,7 @@ bool FilesPatchRequest::GetContentData(std::string* upload_content_type,
   }
 
   AttachProperties(properties_, &root);
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
 
   DVLOG(1) << "FilesPatch data: " << *upload_content_type << ", ["
            << *upload_content << "]";
@@ -545,7 +545,7 @@ bool FilesCopyRequest::GetContentData(std::string* upload_content_type,
   if (!title_.empty())
     root.SetString("title", title_);
 
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
   DVLOG(1) << "FilesCopy data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
@@ -755,7 +755,7 @@ bool ChildrenInsertRequest::GetContentData(std::string* upload_content_type,
   base::DictionaryValue root;
   root.SetString("id", id_);
 
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
   DVLOG(1) << "InsertResource data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
@@ -834,7 +834,7 @@ bool InitiateUploadNewFileRequest::GetContentData(
   }
 
   AttachProperties(properties_, &root);
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
 
   DVLOG(1) << "InitiateUploadNewFile data: " << *upload_content_type << ", ["
            << *upload_content << "]";
@@ -906,7 +906,7 @@ bool InitiateUploadExistingFileRequest::GetContentData(
     return false;
 
   *upload_content_type = util::kContentTypeApplicationJson;
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
   DVLOG(1) << "InitiateUploadExistingFile data: " << *upload_content_type
            << ", [" << *upload_content << "]";
   return true;
@@ -1158,7 +1158,7 @@ bool PermissionsInsertRequest::GetContentData(std::string* upload_content_type,
       break;
   }
   root.SetString("value", value_);
-  base::JSONWriter::Write(&root, upload_content);
+  base::JSONWriter::Write(root, upload_content);
   return true;
 }
 
diff --git a/google_apis/gaia/fake_gaia.cc b/google_apis/gaia/fake_gaia.cc
index bf2331d..1bf87ca 100644
--- a/google_apis/gaia/fake_gaia.cc
+++ b/google_apis/gaia/fake_gaia.cc
@@ -390,7 +390,7 @@ void FakeGaia::HandleProgramaticAuth(
 void FakeGaia::FormatJSONResponse(const base::DictionaryValue& response_dict,
                                   BasicHttpResponse* http_response) {
   std::string response_json;
-  base::JSONWriter::Write(&response_dict, &response_json);
+  base::JSONWriter::Write(response_dict, &response_json);
   http_response->set_content(response_json);
   http_response->set_code(net::HTTP_OK);
 }
diff --git a/gpu/tools/compositor_model_bench/render_tree.cc b/gpu/tools/compositor_model_bench/render_tree.cc
index 8712a97..ff60961 100644
--- a/gpu/tools/compositor_model_bench/render_tree.cc
+++ b/gpu/tools/compositor_model_bench/render_tree.cc
@@ -442,7 +442,7 @@ RenderNode* InterpretNode(base::DictionaryValue* node) {
 
 
   string outjson;
-  JSONWriter::WriteWithOptions(node, base::JSONWriter::OPTIONS_PRETTY_PRINT,
+  JSONWriter::WriteWithOptions(*node, base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                &outjson);
   LOG(ERROR) << "Unrecognized node type! JSON:\n\n"
       "-----------------------\n" <<
diff --git a/ios/web/web_state/ui/crw_web_controller_observer_unittest.mm b/ios/web/web_state/ui/crw_web_controller_observer_unittest.mm
index 9fd9358..9b99c9a 100644
--- a/ios/web/web_state/ui/crw_web_controller_observer_unittest.mm
+++ b/ios/web/web_state/ui/crw_web_controller_observer_unittest.mm
@@ -68,7 +68,7 @@ WEB_TEST_F(CRWUIWebViewWebControllerObserverTest,
   base::DictionaryValue command;
   command.SetString("command", "test.testMessage");
   std::string message;
-  base::JSONWriter::Write(&command, &message);
+  base::JSONWriter::Write(command, &message);
   this->RunJavaScript([NSString
       stringWithFormat:@"__gCrWeb.message.invokeOnHost(%s)", message.c_str()]);
   this->WaitForBackgroundTasks();
@@ -91,7 +91,7 @@ WEB_TEST_F(CRWUIWebViewWebControllerObserverTest,
   command.SetString("target", "target");
   command.SetString("referrerPolicy", "referrerPolicy");
   std::string message;
-  base::JSONWriter::Write(&command, &message);
+  base::JSONWriter::Write(command, &message);
   this->RunJavaScript(
       [NSString stringWithFormat:@"__gCrWeb.message.invokeOnHostImmediate(%s)",
                                  message.c_str()]);
@@ -112,7 +112,7 @@ WEB_TEST_F(CRWUIWebViewWebControllerObserverTest,
   for (int count = 0; count <= kNumberMessages; count++) {
     std::string message;
     command.SetInteger("number", count);
-    base::JSONWriter::Write(&command, &message);
+    base::JSONWriter::Write(command, &message);
     ASSERT_EQ(0U,
               [this->fake_web_controller_observer_ commandsReceived].size());
     this->RunJavaScript(
diff --git a/ios/web/webui/web_ui_ios_impl.mm b/ios/web/webui/web_ui_ios_impl.mm
index 810f3a7..8913f79 100644
--- a/ios/web/webui/web_ui_ios_impl.mm
+++ b/ios/web/webui/web_ui_ios_impl.mm
@@ -27,7 +27,7 @@ base::string16 WebUIIOS::GetJavascriptCall(
     if (i > 0)
       parameters += base::char16(',');
 
-    base::JSONWriter::Write(arg_list[i], &json);
+    base::JSONWriter::Write(*arg_list[i], &json);
     parameters += base::UTF8ToUTF16(json);
   }
   return base::ASCIIToUTF16(function_name) + base::char16('(') + parameters +
diff --git a/ipc/ipc_message_utils.cc b/ipc/ipc_message_utils.cc
index adb14d1..a00e857 100644
--- a/ipc/ipc_message_utils.cc
+++ b/ipc/ipc_message_utils.cc
@@ -451,7 +451,7 @@ bool ParamTraits<base::DictionaryValue>::Read(
 void ParamTraits<base::DictionaryValue>::Log(const param_type& p,
                                              std::string* l) {
   std::string json;
-  base::JSONWriter::Write(&p, &json);
+  base::JSONWriter::Write(p, &json);
   l->append(json);
 }
 
@@ -533,7 +533,7 @@ bool ParamTraits<base::ListValue>::Read(
 
 void ParamTraits<base::ListValue>::Log(const param_type& p, std::string* l) {
   std::string json;
-  base::JSONWriter::Write(&p, &json);
+  base::JSONWriter::Write(p, &json);
   l->append(json);
 }
 
diff --git a/jingle/glue/utils.cc b/jingle/glue/utils.cc
index 4d35650..4c9f4b6 100644
--- a/jingle/glue/utils.cc
+++ b/jingle/glue/utils.cc
@@ -46,7 +46,7 @@ std::string SerializeP2PCandidate(const cricket::Candidate& candidate) {
   value.SetInteger("generation", candidate.generation());
 
   std::string result;
-  base::JSONWriter::Write(&value, &result);
+  base::JSONWriter::Write(value, &result);
   return result;
 }
 
diff --git a/media/base/media_log.cc b/media/base/media_log.cc
index c89c415..462299b 100644
--- a/media/base/media_log.cc
+++ b/media/base/media_log.cc
@@ -139,7 +139,7 @@ std::string MediaLog::MediaEventToLogString(const MediaLogEvent& event) {
         media::MediaLog::PipelineStatusToString(status);
   }
   std::string params_json;
-  base::JSONWriter::Write(&event.params, &params_json);
+  base::JSONWriter::Write(event.params, &params_json);
   return EventTypeToString(event.type) + " " + params_json;
 }
 
diff --git a/media/cast/sender/fake_software_video_encoder.cc b/media/cast/sender/fake_software_video_encoder.cc
index 7a2a333..0cd0139 100644
--- a/media/cast/sender/fake_software_video_encoder.cc
+++ b/media/cast/sender/fake_software_video_encoder.cc
@@ -57,7 +57,7 @@ void FakeSoftwareVideoEncoder::Encode(
   values.SetInteger("ref", encoded_frame->referenced_frame_id);
   values.SetInteger("id", encoded_frame->frame_id);
   values.SetInteger("size", frame_size_);
-  base::JSONWriter::Write(&values, &encoded_frame->data);
+  base::JSONWriter::Write(values, &encoded_frame->data);
   encoded_frame->data.resize(
       std::max<size_t>(encoded_frame->data.size(), frame_size_), ' ');
 }
diff --git a/media/cast/test/sender.cc b/media/cast/test/sender.cc
index e34ecf1..7398698 100644
--- a/media/cast/test/sender.cc
+++ b/media/cast/test/sender.cc
@@ -187,13 +187,13 @@ void WriteStatsAndDestroySubscribers(
   scoped_ptr<base::DictionaryValue> stats = video_event_subscriber->GetStats();
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      stats.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      *stats, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   VLOG(0) << "Video stats: " << json;
 
   stats = audio_event_subscriber->GetStats();
   json.clear();
   base::JSONWriter::WriteWithOptions(
-      stats.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      *stats, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   VLOG(0) << "Audio stats: " << json;
 }
 
diff --git a/media/cast/test/simulator.cc b/media/cast/test/simulator.cc
index 6c277d5..a3a560e 100644
--- a/media/cast/test/simulator.cc
+++ b/media/cast/test/simulator.cc
@@ -766,7 +766,7 @@ int main(int argc, char** argv) {
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
-  base::JSONWriter::Write(&values, &extra_data);
+  base::JSONWriter::Write(values, &extra_data);
 
   // Run.
   media::cast::RunSimulation(source_path, log_output_path, metrics_output_path,
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index ea328a5..dc2da50 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -127,7 +127,7 @@ bool GetHeaders(base::DictionaryValue* params, std::string* headers) {
   if (!params->GetList("headers", &header_list))
     return false;
   std::string double_quote_headers;
-  base::JSONWriter::Write(header_list, &double_quote_headers);
+  base::JSONWriter::Write(*header_list, &double_quote_headers);
   base::ReplaceChars(double_quote_headers, "\"", "'", headers);
   return true;
 }
diff --git a/net/http/http_server_properties_manager_unittest.cc b/net/http/http_server_properties_manager_unittest.cc
index 7ab6ef0..414613c 100644
--- a/net/http/http_server_properties_manager_unittest.cc
+++ b/net/http/http_server_properties_manager_unittest.cc
@@ -708,7 +708,7 @@ TEST_F(HttpServerPropertiesManagerTest, UpdateCacheWithPrefs) {
   ASSERT_NE(nullptr, http_server_properties);
   std::string preferences_json;
   EXPECT_TRUE(
-      base::JSONWriter::Write(http_server_properties, &preferences_json));
+      base::JSONWriter::Write(*http_server_properties, &preferences_json));
   EXPECT_EQ(expected_json, preferences_json);
 }
 
diff --git a/net/http/transport_security_persister.cc b/net/http/transport_security_persister.cc
index 08aa07e..2242200 100644
--- a/net/http/transport_security_persister.cc
+++ b/net/http/transport_security_persister.cc
@@ -171,9 +171,8 @@ bool TransportSecurityPersister::SerializeData(std::string* output) {
     toplevel.Set(HashedDomainToExternalString(hostname), serialized);
   }
 
-  base::JSONWriter::WriteWithOptions(&toplevel,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     output);
+  base::JSONWriter::WriteWithOptions(
+      toplevel, base::JSONWriter::OPTIONS_PRETTY_PRINT, output);
   return true;
 }
 
diff --git a/net/log/test_net_log_entry.cc b/net/log/test_net_log_entry.cc
index 948693b..34e9ffa 100644
--- a/net/log/test_net_log_entry.cc
+++ b/net/log/test_net_log_entry.cc
@@ -76,7 +76,7 @@ std::string TestNetLogEntry::GetParamsJson() const {
   if (!params)
     return std::string();
   std::string json;
-  base::JSONWriter::Write(params.get(), &json);
+  base::JSONWriter::Write(*params, &json);
   return json;
 }
 
diff --git a/net/log/trace_net_log_observer.cc b/net/log/trace_net_log_observer.cc
index 2ce8bc0..4978e64 100644
--- a/net/log/trace_net_log_observer.cc
+++ b/net/log/trace_net_log_observer.cc
@@ -32,7 +32,7 @@ class TracedValue : public base::trace_event::ConvertableToTraceFormat {
   void AppendAsTraceFormat(std::string* out) const override {
     if (value_) {
       std::string tmp;
-      base::JSONWriter::Write(value_.get(), &tmp);
+      base::JSONWriter::Write(*value_, &tmp);
       *out += tmp;
     } else {
       *out += "\"\"";
diff --git a/net/log/write_to_file_net_log_observer.cc b/net/log/write_to_file_net_log_observer.cc
index 8ef5a71..5c4f951 100644
--- a/net/log/write_to_file_net_log_observer.cc
+++ b/net/log/write_to_file_net_log_observer.cc
@@ -43,12 +43,11 @@ void WriteToFileNetLogObserver::StartObserving(
   // different source and event types, as they may be added and removed
   // between Chrome versions.
   std::string json;
-  if (constants) {
-    base::JSONWriter::Write(constants, &json);
-  } else {
-    scoped_ptr<base::DictionaryValue> scoped_constants(GetNetConstants());
-    base::JSONWriter::Write(scoped_constants.get(), &json);
-  }
+  if (constants)
+    base::JSONWriter::Write(*constants, &json);
+  else
+    base::JSONWriter::Write(*GetNetConstants(), &json);
+
   fprintf(file_.get(), "{\"constants\": %s,\n", json.c_str());
 
   // Start events array.  It's closed in StopObserving().
@@ -78,9 +77,8 @@ void WriteToFileNetLogObserver::StopObserving(
     DCHECK(url_request_context->CalledOnValidThread());
 
     std::string json;
-    scoped_ptr<base::DictionaryValue> net_info =
-        GetNetInfo(url_request_context, NET_INFO_ALL_SOURCES);
-    base::JSONWriter::Write(net_info.get(), &json);
+    base::JSONWriter::Write(
+        *GetNetInfo(url_request_context, NET_INFO_ALL_SOURCES), &json);
     fprintf(file_.get(), ",\"tabInfo\": %s\n", json.c_str());
   }
   fprintf(file_.get(), "}");
@@ -94,7 +92,7 @@ void WriteToFileNetLogObserver::OnAddEntry(const NetLog::Entry& entry) {
   // work, lines cannot be pretty printed.
   scoped_ptr<base::Value> value(entry.ToValue());
   std::string json;
-  base::JSONWriter::Write(value.get(), &json);
+  base::JSONWriter::Write(*value, &json);
   fprintf(file_.get(), "%s%s", (added_events_ ? ",\n" : ""), json.c_str());
   added_events_ = true;
 }
diff --git a/net/test/spawned_test_server/remote_test_server.cc b/net/test/spawned_test_server/remote_test_server.cc
index 1d1481b..bf2c025 100644
--- a/net/test/spawned_test_server/remote_test_server.cc
+++ b/net/test/spawned_test_server/remote_test_server.cc
@@ -103,7 +103,7 @@ bool RemoteTestServer::Start() {
 
   // Generate JSON-formatted argument string.
   std::string arguments_string;
-  base::JSONWriter::Write(&arguments_dict, &arguments_string);
+  base::JSONWriter::Write(arguments_dict, &arguments_string);
   if (arguments_string.empty())
     return false;
 
@@ -123,7 +123,7 @@ bool RemoteTestServer::Start() {
   // the remote server.
   server_data_dict.SetInteger("port", test_server_port);
   std::string server_data;
-  base::JSONWriter::Write(&server_data_dict, &server_data);
+  base::JSONWriter::Write(server_data_dict, &server_data);
   if (server_data.empty() || !ParseServerData(server_data)) {
     LOG(ERROR) << "Could not parse server_data: " << server_data;
     return false;
diff --git a/net/tools/get_server_time/get_server_time.cc b/net/tools/get_server_time/get_server_time.cc
index 9915e8e..fe1c124 100644
--- a/net/tools/get_server_time/get_server_time.cc
+++ b/net/tools/get_server_time/get_server_time.cc
@@ -122,7 +122,7 @@ class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
     scoped_ptr<base::Value> params(entry.ParametersToValue());
     std::string params_str;
     if (params.get()) {
-      base::JSONWriter::Write(params.get(), &params_str);
+      base::JSONWriter::Write(*params, &params_str);
       params_str.insert(0, ": ");
     }
 
diff --git a/net/tools/net_watcher/net_watcher.cc b/net/tools/net_watcher/net_watcher.cc
index 8d1d056..02c373a 100644
--- a/net/tools/net_watcher/net_watcher.cc
+++ b/net/tools/net_watcher/net_watcher.cc
@@ -71,7 +71,7 @@ const char* ConnectionTypeToString(
 std::string ProxyConfigToString(const net::ProxyConfig& config) {
   scoped_ptr<base::Value> config_value(config.ToValue());
   std::string str;
-  base::JSONWriter::Write(config_value.get(), &str);
+  base::JSONWriter::Write(*config_value, &str);
   return str;
 }
 
diff --git a/pdf/out_of_process_instance.cc b/pdf/out_of_process_instance.cc
index 8c240a6..d8188ad 100644
--- a/pdf/out_of_process_instance.cc
+++ b/pdf/out_of_process_instance.cc
@@ -469,7 +469,7 @@ void OutOfProcessInstance::HandleMessage(const pp::Var& message) {
           engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE);
       node.SetBoolean(kAccessibleCopyable, has_permissions);
       std::string json;
-      base::JSONWriter::Write(&node, &json);
+      base::JSONWriter::Write(node, &json);
       reply.Set(pp::Var(kJSAccessibilityJSON), pp::Var(json));
     }
     PostMessage(reply);
diff --git a/pdf/pdfium/pdfium_engine.cc b/pdf/pdfium/pdfium_engine.cc
index e463f15..f4df4a9 100644
--- a/pdf/pdfium/pdfium_engine.cc
+++ b/pdf/pdfium/pdfium_engine.cc
@@ -2434,7 +2434,7 @@ std::string PDFiumEngine::GetPageAsJSON(int index) {
   scoped_ptr<base::Value> node(
       pages_[index]->GetAccessibleContentAsValue(current_rotation_));
   std::string page_json;
-  base::JSONWriter::Write(node.get(), &page_json);
+  base::JSONWriter::Write(*node, &page_json);
   return page_json;
 }
 
diff --git a/printing/printed_document.cc b/printing/printed_document.cc
index 62fbef8..3b17eff 100644
--- a/printing/printed_document.cc
+++ b/printing/printed_document.cc
@@ -78,7 +78,7 @@ void DebugDumpSettings(const base::string16& doc_name,
   PrintSettingsToJobSettingsDebug(settings, &job_settings);
   std::string settings_str;
   base::JSONWriter::WriteWithOptions(
-      &job_settings, base::JSONWriter::OPTIONS_PRETTY_PRINT, &settings_str);
+      job_settings, base::JSONWriter::OPTIONS_PRETTY_PRINT, &settings_str);
   scoped_refptr<base::RefCountedMemory> data =
       base::RefCountedString::TakeString(&settings_str);
   blocking_runner->PostTask(
diff --git a/remoting/base/vlog_net_log.cc b/remoting/base/vlog_net_log.cc
index 39a388a..bfcea02 100644
--- a/remoting/base/vlog_net_log.cc
+++ b/remoting/base/vlog_net_log.cc
@@ -35,7 +35,7 @@ void VlogNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
   if (VLOG_IS_ON(4)) {
     scoped_ptr<base::Value> value(entry.ToValue());
     std::string json;
-    base::JSONWriter::Write(value.get(), &json);
+    base::JSONWriter::Write(*value, &json);
     VLOG(4) << json;
   }
 }
diff --git a/remoting/client/plugin/chromoting_instance.cc b/remoting/client/plugin/chromoting_instance.cc
index 3faab96..a3544aa 100644
--- a/remoting/client/plugin/chromoting_instance.cc
+++ b/remoting/client/plugin/chromoting_instance.cc
@@ -1016,12 +1016,12 @@ void ChromotingInstance::PostChromotingMessage(const std::string& method,
 void ChromotingInstance::PostLegacyJsonMessage(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> data) {
-  scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
-  message->SetString("method", method);
-  message->Set("data", data.release());
+  base::DictionaryValue message;
+  message.SetString("method", method);
+  message.Set("data", data.release());
 
   std::string message_json;
-  base::JSONWriter::Write(message.get(), &message_json);
+  base::JSONWriter::Write(message, &message_json);
   PostMessage(pp::Var(message_json));
 }
 
diff --git a/remoting/host/cast_extension_session.cc b/remoting/host/cast_extension_session.cc
index 9bceaa6..843a79d 100644
--- a/remoting/host/cast_extension_session.cc
+++ b/remoting/host/cast_extension_session.cc
@@ -202,15 +202,15 @@ void CastExtensionSession::OnCreateSessionDescription(
   peer_connection_->SetLocalDescription(
       CastSetSessionDescriptionObserver::Create(), desc);
 
-  scoped_ptr<base::DictionaryValue> json(new base::DictionaryValue());
-  json->SetString(kWebRtcSessionDescType, desc->type());
+  base::DictionaryValue json;
+  json.SetString(kWebRtcSessionDescType, desc->type());
   std::string subject =
       (desc->type() == "offer") ? kSubjectOffer : kSubjectAnswer;
   std::string desc_str;
   desc->ToString(&desc_str);
-  json->SetString(kWebRtcSessionDescSDP, desc_str);
+  json.SetString(kWebRtcSessionDescSDP, desc_str);
   std::string json_str;
-  if (!base::JSONWriter::Write(json.get(), &json_str)) {
+  if (!base::JSONWriter::Write(json, &json_str)) {
     LOG(ERROR) << "Failed to serialize sdp message.";
     return;
   }
@@ -420,7 +420,7 @@ bool CastExtensionSession::SendMessageToClient(const std::string& subject,
   message_dict.SetString(kTopLevelData, data);
   std::string message_json;
 
-  if (!base::JSONWriter::Write(&message_dict, &message_json)) {
+  if (!base::JSONWriter::Write(message_dict, &message_json)) {
     LOG(ERROR) << "Failed to serialize JSON message.";
     return false;
   }
@@ -647,12 +647,12 @@ void CastExtensionSession::OnIceCandidate(
     LOG(ERROR) << "PeerConnectionObserver: failed to serialize candidate.";
     return;
   }
-  scoped_ptr<base::DictionaryValue> json(new base::DictionaryValue());
-  json->SetString(kWebRtcSDPMid, candidate->sdp_mid());
-  json->SetInteger(kWebRtcSDPMLineIndex, candidate->sdp_mline_index());
-  json->SetString(kWebRtcCandidate, candidate_str);
+  base::DictionaryValue json;
+  json.SetString(kWebRtcSDPMid, candidate->sdp_mid());
+  json.SetInteger(kWebRtcSDPMLineIndex, candidate->sdp_mline_index());
+  json.SetString(kWebRtcCandidate, candidate_str);
   std::string json_str;
-  if (!base::JSONWriter::Write(json.get(), &json_str)) {
+  if (!base::JSONWriter::Write(json, &json_str)) {
     LOG(ERROR) << "Failed to serialize candidate message.";
     return;
   }
diff --git a/remoting/host/gnubby_auth_handler_posix.cc b/remoting/host/gnubby_auth_handler_posix.cc
index 13c8f41..4639f01 100644
--- a/remoting/host/gnubby_auth_handler_posix.cc
+++ b/remoting/host/gnubby_auth_handler_posix.cc
@@ -174,7 +174,7 @@ void GnubbyAuthHandlerPosix::DeliverHostDataMessage(
   request.Set(kDataPayload, bytes);
 
   std::string request_json;
-  if (!base::JSONWriter::Write(&request, &request_json)) {
+  if (!base::JSONWriter::Write(request, &request_json)) {
     LOG(ERROR) << "Failed to create request json";
     return;
   }
diff --git a/remoting/host/host_config.cc b/remoting/host/host_config.cc
index 40ae940..2250d6f 100644
--- a/remoting/host/host_config.cc
+++ b/remoting/host/host_config.cc
@@ -28,7 +28,7 @@ scoped_ptr<base::DictionaryValue> HostConfigFromJson(
 
 std::string HostConfigToJson(const base::DictionaryValue& host_config) {
   std::string data;
-  base::JSONWriter::Write(&host_config, &data);
+  base::JSONWriter::Write(host_config, &data);
   return data;
 }
 
diff --git a/remoting/host/it2me/it2me_native_messaging_host.cc b/remoting/host/it2me/it2me_native_messaging_host.cc
index 7af2db74..441224e 100644
--- a/remoting/host/it2me/it2me_native_messaging_host.cc
+++ b/remoting/host/it2me/it2me_native_messaging_host.cc
@@ -121,7 +121,7 @@ void It2MeNativeMessagingHost::SendMessageToClient(
     scoped_ptr<base::DictionaryValue> message) const {
   DCHECK(task_runner()->BelongsToCurrentThread());
   std::string message_json;
-  base::JSONWriter::Write(message.get(), &message_json);
+  base::JSONWriter::Write(*message, &message_json);
   client_->PostMessageFromNativeHost(message_json);
 }
 
diff --git a/remoting/host/it2me/it2me_native_messaging_host_unittest.cc b/remoting/host/it2me/it2me_native_messaging_host_unittest.cc
index a6c6724..cfe66bb 100644
--- a/remoting/host/it2me/it2me_native_messaging_host_unittest.cc
+++ b/remoting/host/it2me/it2me_native_messaging_host_unittest.cc
@@ -291,7 +291,7 @@ It2MeNativeMessagingHostTest::ReadMessageFromOutputPipe() {
 void It2MeNativeMessagingHostTest::WriteMessageToInputPipe(
     const base::Value& message) {
   std::string message_json;
-  base::JSONWriter::Write(&message, &message_json);
+  base::JSONWriter::Write(message, &message_json);
 
   uint32 length = message_json.length();
   input_write_file_.WriteAtCurrentPos(reinterpret_cast<char*>(&length),
diff --git a/remoting/host/native_messaging/native_messaging_pipe.cc b/remoting/host/native_messaging/native_messaging_pipe.cc
index 8521472..da204d1 100644
--- a/remoting/host/native_messaging/native_messaging_pipe.cc
+++ b/remoting/host/native_messaging/native_messaging_pipe.cc
@@ -27,7 +27,7 @@ void NativeMessagingPipe::Start(
 
 void NativeMessagingPipe::OnMessage(scoped_ptr<base::Value> message) {
   std::string message_json;
-  base::JSONWriter::Write(message.get(), &message_json);
+  base::JSONWriter::Write(*message, &message_json);
   host_->OnMessage(message_json);
 }
 
diff --git a/remoting/host/native_messaging/native_messaging_writer.cc b/remoting/host/native_messaging/native_messaging_writer.cc
index 3266fdb7..030cfd3 100644
--- a/remoting/host/native_messaging/native_messaging_writer.cc
+++ b/remoting/host/native_messaging/native_messaging_writer.cc
@@ -44,7 +44,7 @@ bool NativeMessagingWriter::WriteMessage(const base::Value& message) {
   }
 
   std::string message_json;
-  base::JSONWriter::Write(&message, &message_json);
+  base::JSONWriter::Write(message, &message_json);
 
   CHECK_LE(message_json.length(), kMaximumMessageSize);
 
diff --git a/remoting/host/policy_watcher_unittest.cc b/remoting/host/policy_watcher_unittest.cc
index 1d683cb..b9cbefd 100644
--- a/remoting/host/policy_watcher_unittest.cc
+++ b/remoting/host/policy_watcher_unittest.cc
@@ -27,11 +27,11 @@ MATCHER_P(IsPolicies, dict, "") {
   if (!equal) {
     std::string actual_value;
     base::JSONWriter::WriteWithOptions(
-        arg, base::JSONWriter::OPTIONS_PRETTY_PRINT, &actual_value);
+        *arg, base::JSONWriter::OPTIONS_PRETTY_PRINT, &actual_value);
 
     std::string expected_value;
     base::JSONWriter::WriteWithOptions(
-        dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &expected_value);
+        *dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &expected_value);
 
     *result_listener << "Policies are not equal. ";
     *result_listener << "Expected policy: " << expected_value << ". ";
diff --git a/remoting/host/setup/daemon_controller_delegate_win.cc b/remoting/host/setup/daemon_controller_delegate_win.cc
index 0dcae69..1795110 100644
--- a/remoting/host/setup/daemon_controller_delegate_win.cc
+++ b/remoting/host/setup/daemon_controller_delegate_win.cc
@@ -186,7 +186,7 @@ bool WriteConfig(const std::string& content) {
     }
   }
   std::string unprivileged_config_str;
-  base::JSONWriter::Write(&unprivileged_config_dict, &unprivileged_config_str);
+  base::JSONWriter::Write(unprivileged_config_dict, &unprivileged_config_str);
 
   // Write the full configuration file to a temporary location.
   base::FilePath full_config_file_path =
@@ -413,7 +413,7 @@ void DaemonControllerDelegateWin::UpdateConfig(
 
   // Write the updated config.
   std::string config_updated_str;
-  base::JSONWriter::Write(config_old.get(), &config_updated_str);
+  base::JSONWriter::Write(*config_old, &config_updated_str);
   bool result = WriteConfig(config_updated_str);
 
   InvokeCompletionCallback(done, result);
@@ -458,7 +458,7 @@ void DaemonControllerDelegateWin::SetConfigAndStart(
 
   // Set the configuration.
   std::string config_str;
-  base::JSONWriter::Write(config.release(), &config_str);
+  base::JSONWriter::Write(*config, &config_str);
 
   // Determine the config directory path and create it if necessary.
   base::FilePath config_dir = remoting::GetConfigDir();
diff --git a/remoting/host/setup/me2me_native_messaging_host_unittest.cc b/remoting/host/setup/me2me_native_messaging_host_unittest.cc
index bdd6daf..b44c2bd 100644
--- a/remoting/host/setup/me2me_native_messaging_host_unittest.cc
+++ b/remoting/host/setup/me2me_native_messaging_host_unittest.cc
@@ -409,7 +409,7 @@ Me2MeNativeMessagingHostTest::ReadMessageFromOutputPipe() {
 void Me2MeNativeMessagingHostTest::WriteMessageToInputPipe(
     const base::Value& message) {
   std::string message_json;
-  base::JSONWriter::Write(&message, &message_json);
+  base::JSONWriter::Write(message, &message_json);
 
   uint32 length = message_json.length();
   input_write_file_.WriteAtCurrentPos(reinterpret_cast<char*>(&length),
diff --git a/remoting/host/setup/service_client.cc b/remoting/host/setup/service_client.cc
index 260f762..f99f6a6 100644
--- a/remoting/host/setup/service_client.cc
+++ b/remoting/host/setup/service_client.cc
@@ -83,7 +83,7 @@ void ServiceClient::Core::RegisterHost(
   if (!host_client_id.empty())
     url_suffix = "?hostClientId=" + host_client_id;
   std::string post_body_str;
-  base::JSONWriter::Write(&post_body, &post_body_str);
+  base::JSONWriter::Write(post_body, &post_body_str);
   MakeChromotingRequest(net::URLFetcher::POST,
                         url_suffix,
                         post_body_str,
diff --git a/remoting/host/token_validator_factory_impl_unittest.cc b/remoting/host/token_validator_factory_impl_unittest.cc
index bfbed9f..aa5a024 100644
--- a/remoting/host/token_validator_factory_impl_unittest.cc
+++ b/remoting/host/token_validator_factory_impl_unittest.cc
@@ -108,7 +108,7 @@ class TokenValidatorFactoryImplTest : public testing::Test {
     response_dict.SetString("token_type", "shared_secret");
     response_dict.SetString("scope", scope);
     std::string response;
-    base::JSONWriter::Write(&response_dict, &response);
+    base::JSONWriter::Write(response_dict, &response);
     return response;
   }
 
@@ -116,7 +116,7 @@ class TokenValidatorFactoryImplTest : public testing::Test {
     base::DictionaryValue response_dict;
     response_dict.SetString("error", error);
     std::string response;
-    base::JSONWriter::Write(&response_dict, &response);
+    base::JSONWriter::Write(response_dict, &response);
     return response;
   }
 
diff --git a/remoting/host/video_frame_recorder_host_extension.cc b/remoting/host/video_frame_recorder_host_extension.cc
index 61bd746..efa110e 100644
--- a/remoting/host/video_frame_recorder_host_extension.cc
+++ b/remoting/host/video_frame_recorder_host_extension.cc
@@ -159,7 +159,7 @@ void VideoFrameRecorderHostExtensionSession::OnNextFrame(
   // Note that JSONWriter::Write() can only fail due to invalid inputs, and will
   // DCHECK in Debug builds in that case.
   std::string reply_json;
-  if (!base::JSONWriter::Write(&reply_message, &reply_json)) {
+  if (!base::JSONWriter::Write(reply_message, &reply_json)) {
     return;
   }
 
diff --git a/sync/api/sync_data.cc b/sync/api/sync_data.cc
index 0dd567d..d6c9152 100644
--- a/sync/api/sync_data.cc
+++ b/sync/api/sync_data.cc
@@ -155,10 +155,9 @@ std::string SyncData::ToString() const {
 
   std::string type = ModelTypeToString(GetDataType());
   std::string specifics;
-  scoped_ptr<base::DictionaryValue> value(
-      EntitySpecificsToValue(GetSpecifics()));
-  base::JSONWriter::WriteWithOptions(
-      value.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &specifics);
+  base::JSONWriter::WriteWithOptions(*EntitySpecificsToValue(GetSpecifics()),
+                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                     &specifics);
 
   if (IsLocal()) {
     SyncDataLocal sync_data_local(*this);
diff --git a/sync/engine/traffic_logger.cc b/sync/engine/traffic_logger.cc
index bc285bd..1e9a6bc 100644
--- a/sync/engine/traffic_logger.cc
+++ b/sync/engine/traffic_logger.cc
@@ -25,9 +25,8 @@ void LogData(const T& data,
     scoped_ptr<base::DictionaryValue> value =
         (*to_dictionary_value)(data, true /* include_specifics */);
     std::string message;
-    base::JSONWriter::WriteWithOptions(value.get(),
-        base::JSONWriter::OPTIONS_PRETTY_PRINT,
-        &message);
+    base::JSONWriter::WriteWithOptions(
+        *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &message);
     DVLOG(1) << "\n" << description << "\n" << message << "\n";
   }
 }
diff --git a/sync/internal_api/public/engine/model_safe_worker.cc b/sync/internal_api/public/engine/model_safe_worker.cc
index 9692a78..f054e50 100644
--- a/sync/internal_api/public/engine/model_safe_worker.cc
+++ b/sync/internal_api/public/engine/model_safe_worker.cc
@@ -24,10 +24,8 @@ scoped_ptr<base::DictionaryValue> ModelSafeRoutingInfoToValue(
 
 std::string ModelSafeRoutingInfoToString(
     const ModelSafeRoutingInfo& routing_info) {
-  scoped_ptr<base::DictionaryValue> dict =
-      ModelSafeRoutingInfoToValue(routing_info);
   std::string json;
-  base::JSONWriter::Write(dict.get(), &json);
+  base::JSONWriter::Write(*ModelSafeRoutingInfoToValue(routing_info), &json);
   return json;
 }
 
diff --git a/sync/internal_api/public/sessions/sync_session_snapshot.cc b/sync/internal_api/public/sessions/sync_session_snapshot.cc
index dcb3f73..9614330 100644
--- a/sync/internal_api/public/sessions/sync_session_snapshot.cc
+++ b/sync/internal_api/public/sessions/sync_session_snapshot.cc
@@ -105,7 +105,7 @@ scoped_ptr<base::DictionaryValue> SyncSessionSnapshot::ToValue() const {
 std::string SyncSessionSnapshot::ToString() const {
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      ToValue().get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      *ToValue(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
diff --git a/sync/js/js_event_details.cc b/sync/js/js_event_details.cc
index 0517b39..d430632 100644
--- a/sync/js/js_event_details.cc
+++ b/sync/js/js_event_details.cc
@@ -21,7 +21,7 @@ const base::DictionaryValue& JsEventDetails::Get() const {
 
 std::string JsEventDetails::ToString() const {
   std::string str;
-  base::JSONWriter::Write(&Get(), &str);
+  base::JSONWriter::Write(Get(), &str);
   return str;
 }
 
diff --git a/sync/syncable/nigori_util.cc b/sync/syncable/nigori_util.cc
index 1eb9227..1ad5095 100644
--- a/sync/syncable/nigori_util.cc
+++ b/sync/syncable/nigori_util.cc
@@ -175,9 +175,8 @@ bool UpdateEntryWithEncryption(
     if (VLOG_IS_ON(2)) {
       scoped_ptr<base::DictionaryValue> value(entry->ToValue(NULL));
       std::string info;
-      base::JSONWriter::WriteWithOptions(value.get(),
-                                         base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                         &info);
+      base::JSONWriter::WriteWithOptions(
+          *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &info);
       DVLOG(2) << "Encrypting specifics of type "
                << ModelTypeToString(type)
                << " with content: "
diff --git a/sync/test/fake_server/fake_server_verifier.cc b/sync/test/fake_server/fake_server_verifier.cc
index bc64550..b968d0f 100644
--- a/sync/test/fake_server/fake_server_verifier.cc
+++ b/sync/test/fake_server/fake_server_verifier.cc
@@ -53,8 +53,7 @@ AssertionResult VerifySessionsHierarchyEquality(
 string ConvertFakeServerContentsToString(
     const base::DictionaryValue& entities) {
   string entities_str;
-  if (!JSONWriter::WriteWithOptions(&entities,
-                                    JSONWriter::OPTIONS_PRETTY_PRINT,
+  if (!JSONWriter::WriteWithOptions(entities, JSONWriter::OPTIONS_PRETTY_PRINT,
                                     &entities_str)) {
     entities_str = "Could not convert FakeServer contents to string.";
   }
diff --git a/sync/tools/sync_client.cc b/sync/tools/sync_client.cc
index 8422d2e..1106460 100644
--- a/sync/tools/sync_client.cc
+++ b/sync/tools/sync_client.cc
@@ -122,7 +122,7 @@ class NullEncryptor : public Encryptor {
 
 std::string ValueToString(const base::Value& value) {
   std::string str;
-  base::JSONWriter::Write(&value, &str);
+  base::JSONWriter::Write(value, &str);
   return str;
 }
 
diff --git a/ui/compositor/layer.cc b/ui/compositor/layer.cc
index c1347c4..a46c6b9 100644
--- a/ui/compositor/layer.cc
+++ b/ui/compositor/layer.cc
@@ -796,7 +796,7 @@ class LayerDebugInfo : public base::trace_event::ConvertableToTraceFormat {
   void AppendAsTraceFormat(std::string* out) const override {
     base::DictionaryValue dictionary;
     dictionary.SetString("layer_name", name_);
-    base::JSONWriter::Write(&dictionary, out);
+    base::JSONWriter::Write(dictionary, out);
   }
 
  private:
diff --git a/ui/events/latency_info.cc b/ui/events/latency_info.cc
index 69610cf..d815790 100644
--- a/ui/events/latency_info.cc
+++ b/ui/events/latency_info.cc
@@ -108,7 +108,7 @@ LatencyInfoTracedValue::~LatencyInfoTracedValue() {
 
 void LatencyInfoTracedValue::AppendAsTraceFormat(std::string* out) const {
   std::string tmp;
-  base::JSONWriter::Write(value_.get(), &tmp);
+  base::JSONWriter::Write(*value_, &tmp);
   *out += tmp;
 }