Reland: Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/preference/preference_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 153 matching lines @@
      APIPermission::kAccessibilityFeaturesRead,
      APIPermission::kAccessibilityFeaturesModify},
     {"virtualKeyboard", prefs::kAccessibilityVirtualKeyboardEnabled,
      APIPermission::kAccessibilityFeaturesRead,
      APIPermission::kAccessibilityFeaturesModify},
 #endif
 };
 
 class IdentityPrefTransformer : public PrefTransformerInterface {
  public:
-  base::Value* ExtensionToBrowserPref(const base::Value* extension_pref,
-                                      std::string* error,
-                                      bool* bad_message) override {
-    return extension_pref->DeepCopy();
+  std::unique_ptr<base::Value> ExtensionToBrowserPref(
+      const base::Value* extension_pref,
+      std::string* error,
+      bool* bad_message) override {
+    return extension_pref->CreateDeepCopy();
   }
 
-  base::Value* BrowserToExtensionPref(
+  std::unique_ptr<base::Value> BrowserToExtensionPref(
       const base::Value* browser_pref) override {
-    return browser_pref->DeepCopy();
+    return browser_pref->CreateDeepCopy();
   }
 };
 
 class InvertBooleanTransformer : public PrefTransformerInterface {
  public:
-  base::Value* ExtensionToBrowserPref(const base::Value* extension_pref,
-                                      std::string* error,
-                                      bool* bad_message) override {
+  std::unique_ptr<base::Value> ExtensionToBrowserPref(
+      const base::Value* extension_pref,
+      std::string* error,
+      bool* bad_message) override {
     return InvertBooleanValue(extension_pref);
   }
 
-  base::Value* BrowserToExtensionPref(
+  std::unique_ptr<base::Value> BrowserToExtensionPref(
       const base::Value* browser_pref) override {
     return InvertBooleanValue(browser_pref);
   }
 
  private:
-  static base::Value* InvertBooleanValue(const base::Value* value) {
+  static std::unique_ptr<base::Value> InvertBooleanValue(
+      const base::Value* value) {
     bool bool_value = false;
     bool result = value->GetAsBoolean(&bool_value);
     DCHECK(result);
-    return new base::Value(!bool_value);
+    return base::MakeUnique<base::Value>(!bool_value);
   }
 };
 
 class NetworkPredictionTransformer : public PrefTransformerInterface {
  public:
-  base::Value* ExtensionToBrowserPref(const base::Value* extension_pref,
-                                      std::string* error,
-                                      bool* bad_message) override {
+  std::unique_ptr<base::Value> ExtensionToBrowserPref(
+      const base::Value* extension_pref,
+      std::string* error,
+      bool* bad_message) override {
     bool bool_value = false;
     const bool pref_found = extension_pref->GetAsBoolean(&bool_value);
     DCHECK(pref_found) << "Preference not found.";
     if (bool_value) {
-      return new base::Value(chrome_browser_net::NETWORK_PREDICTION_DEFAULT);
+      return base::MakeUnique<base::Value>(
+          chrome_browser_net::NETWORK_PREDICTION_DEFAULT);
     } else {
-      return new base::Value(chrome_browser_net::NETWORK_PREDICTION_NEVER);
+      return base::MakeUnique<base::Value>(
+          chrome_browser_net::NETWORK_PREDICTION_NEVER);
     }
   }
 
-  base::Value* BrowserToExtensionPref(
+  std::unique_ptr<base::Value> BrowserToExtensionPref(
       const base::Value* browser_pref) override {
     int int_value = chrome_browser_net::NETWORK_PREDICTION_DEFAULT;
     const bool pref_found = browser_pref->GetAsInteger(&int_value);
     DCHECK(pref_found) << "Preference not found.";
-    return new base::Value(int_value !=
-                           chrome_browser_net::NETWORK_PREDICTION_NEVER);
+    return base::MakeUnique<base::Value>(
+        int_value != chrome_browser_net::NETWORK_PREDICTION_NEVER);
   }
 };
 
 class PrefMapping {
  public:
   static PrefMapping* GetInstance() {
     return base::Singleton<PrefMapping>::get();
   }
 
   bool FindBrowserPrefForExtensionPref(const std::string& extension_pref,
@@ skipping 138 matching lines @@
   bool rv = PrefMapping::GetInstance()->FindEventForBrowserPref(
       browser_pref, &event_name, &permission);
   DCHECK(rv);
 
   base::ListValue args;
   const PrefService::Preference* pref =
       pref_service->FindPreference(browser_pref);
   CHECK(pref);
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
-  base::Value* transformed_value =
+  std::unique_ptr<base::Value> transformed_value =
       transformer->BrowserToExtensionPref(pref->GetValue());
   if (!transformed_value) {
     LOG(ERROR) << ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                  pref->name());
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->Set(keys::kValue, transformed_value);
+  dict->Set(keys::kValue, std::move(transformed_value));
   if (incognito) {
     ExtensionPrefs* ep = ExtensionPrefs::Get(profile_);
     dict->SetBoolean(keys::kIncognitoSpecific,
                      ep->HasIncognitoPrefValue(browser_pref));
   }
   args.Append(std::move(dict));
 
   // TODO(kalman): Have a histogram value for each pref type.
   // This isn't so important for the current use case of these
   // histograms, which is to track which event types are waking up event
@@ skipping 28 matching lines @@
   // ScopeToPrefName() returns false if the scope is not persisted.
   if (pref_names::ScopeToPrefName(scope, &scope_string)) {
     // Also store in persisted Preferences file to recover after a
     // browser restart.
     ExtensionPrefs::ScopedDictionaryUpdate update(extension_prefs(),
                                                   extension_id,
                                                   scope_string);
     base::DictionaryValue* preference = update.Get();
     if (!preference)
       preference = update.Create();
-    preference->SetWithoutPathExpansion(pref_key, value->DeepCopy());
+    preference->SetWithoutPathExpansion(pref_key, value->CreateDeepCopy());
   }
   extension_pref_value_map()->SetExtensionPref(
       extension_id, pref_key, scope, value);
 }
 
 void PreferenceAPIBase::RemoveExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
     ExtensionPrefsScope scope) {
   DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key))
@@ skipping 166 matching lines @@
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 
   // Retrieve level of control.
   std::string level_of_control = helpers::GetLevelOfControl(
       profile, extension_id(), browser_pref, incognito);
   result->SetString(keys::kLevelOfControl, level_of_control);
 
   // Retrieve pref value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
-  base::Value* transformed_value =
+  std::unique_ptr<base::Value> transformed_value =
       transformer->BrowserToExtensionPref(pref->GetValue());
   if (!transformed_value) {
     // TODO(devlin): Can this happen?  When?  Should it be an error, or a bad
     // message?
     LOG(ERROR) <<
         ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                 pref->name());
     return RespondNow(Error(kUnknownErrorDoNotUse));
   }
-  result->Set(keys::kValue, transformed_value);
+  result->Set(keys::kValue, std::move(transformed_value));
 
   // Retrieve incognito status.
   if (incognito) {
     ExtensionPrefs* ep = ExtensionPrefs::Get(browser_context());
     result->SetBoolean(keys::kIncognitoSpecific,
                        ep->HasIncognitoPrefValue(browser_pref));
   }
 
   return RespondNow(OneArgument(std::move(result)));
 }
@@ skipping 118 matching lines @@
       pref_key, &browser_pref, &read_permission, &write_permission));
   if (!extension()->permissions_data()->HasAPIPermission(write_permission))
     return RespondNow(Error(keys::kPermissionErrorMessage, pref_key));
 
   PreferenceAPI::Get(browser_context())
       ->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions