Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/extension_action_storage_manager.cc

 // Copyright 2014 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/extension_action_storage_manager.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/state_store.h"
 #include "extensions/common/constants.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 129 matching lines @@
             static_cast<float>(icon_size) / ExtensionAction::ActionIconSize();
         icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
       }
     }
     action->SetIcon(kDefaultTabId, gfx::Image(icon));
   }
 }
 
 // Store |action|'s default values in a DictionaryValue for use in storing to
 // disk.
-scoped_ptr<base::DictionaryValue> DefaultsToValue(ExtensionAction* action) {
+std::unique_ptr<base::DictionaryValue> DefaultsToValue(
+    ExtensionAction* action) {
   const int kDefaultTabId = ExtensionAction::kDefaultTabId;
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   dict->SetString(kPopupUrlStorageKey,
                   action->GetPopupUrl(kDefaultTabId).spec());
   dict->SetString(kTitleStorageKey, action->GetTitle(kDefaultTabId));
   dict->SetString(kBadgeTextStorageKey, action->GetBadgeText(kDefaultTabId));
   dict->SetString(
       kBadgeBackgroundColorStorageKey,
       SkColorToRawString(action->GetBadgeBackgroundColor(kDefaultTabId)));
   dict->SetString(kBadgeTextColorStorageKey,
                   SkColorToRawString(action->GetBadgeTextColor(kDefaultTabId)));
   dict->SetInteger(kAppearanceStorageKey,
                    action->GetIsVisible(kDefaultTabId) ? ACTIVE : INVISIBLE);
 
   gfx::ImageSkia icon =
       action->GetExplicitlySetIcon(kDefaultTabId).AsImageSkia();
   if (!icon.isNull()) {
-    scoped_ptr<base::DictionaryValue> icon_value(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> icon_value(
+        new base::DictionaryValue());
     std::vector<gfx::ImageSkiaRep> image_reps = icon.image_reps();
     for (const gfx::ImageSkiaRep& rep : image_reps) {
       int size = static_cast<int>(rep.scale() * icon.width());
       std::string size_string = base::IntToString(size);
       icon_value->SetString(size_string, BitmapToString(rep.sk_bitmap()));
     }
     dict->Set(kIconStorageKey, std::move(icon_value));
   }
   return dict;
 }
@@ skipping 45 matching lines @@
 }
 
 void ExtensionActionStorageManager::OnExtensionActionAPIShuttingDown() {
   extension_action_observer_.RemoveAll();
 }
 
 void ExtensionActionStorageManager::WriteToStorage(
     ExtensionAction* extension_action) {
   StateStore* store = GetStateStore();
   if (store) {
-    scoped_ptr<base::DictionaryValue> defaults =
+    std::unique_ptr<base::DictionaryValue> defaults =
         DefaultsToValue(extension_action);
     store->SetExtensionValue(extension_action->extension_id(),
                              kBrowserActionStorageKey, std::move(defaults));
   }
 }
 
 void ExtensionActionStorageManager::ReadFromStorage(
-    const std::string& extension_id, scoped_ptr<base::Value> value) {
+    const std::string& extension_id,
+    std::unique_ptr<base::Value> value) {
   const Extension* extension = ExtensionRegistry::Get(browser_context_)->
       enabled_extensions().GetByID(extension_id);
   if (!extension)
     return;
 
   ExtensionAction* browser_action =
       ExtensionActionManager::Get(browser_context_)->GetBrowserAction(
           *extension);
   if (!browser_action) {
     // This can happen if the extension is updated between startup and when the
     // storage read comes back, and the update removes the browser action.
     // http://crbug.com/349371
     return;
   }
 
   const base::DictionaryValue* dict = NULL;
   if (!value.get() || !value->GetAsDictionary(&dict))
     return;
 
   SetDefaultsFromValue(dict, browser_action);
 }
 
 StateStore* ExtensionActionStorageManager::GetStateStore() {
   return ExtensionSystem::Get(browser_context_)->state_store();
 }
 
 }  // namespace extensions