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

chrome/browser/extensions/menu_manager.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/menu_manager.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 71 matching lines @@
       continue;
     MenuItem* item = MenuItem::Populate(
         extension_id, *dict, NULL);
     if (!item)
       continue;
     items.push_back(item);
   }
   return items;
 }
 
-scoped_ptr<base::Value> MenuItemsToValue(const MenuItem::List& items) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+std::unique_ptr<base::Value> MenuItemsToValue(const MenuItem::List& items) {
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < items.size(); ++i)
     list->Append(items[i]->ToValue().release());
-  return scoped_ptr<base::Value>(list.release());
+  return std::unique_ptr<base::Value>(list.release());
 }
 
 bool GetStringList(const base::DictionaryValue& dict,
                    const std::string& key,
                    std::vector<std::string>* out) {
   if (!dict.HasKey(key))
     return true;
 
   const base::ListValue* list = NULL;
   if (!dict.GetListWithoutPathExpansion(key, &list))
@@ skipping 81 matching lines @@
     return false;
   checked_ = checked;
   return true;
 }
 
 void MenuItem::AddChild(MenuItem* item) {
   item->parent_id_.reset(new Id(id_));
   children_.push_back(item);
 }
 
-scoped_ptr<base::DictionaryValue> MenuItem::ToValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> MenuItem::ToValue() const {
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   // Should only be called for extensions with event pages, which only have
   // string IDs for items.
   DCHECK_EQ(0, id_.uid);
   value->SetString(kStringUIDKey, id_.string_uid);
   value->SetBoolean(kIncognitoKey, id_.incognito);
   value->SetInteger(kTypeKey, type_);
   if (type_ != SEPARATOR)
     value->SetString(kTitleKey, title_);
   if (type_ == CHECKBOX || type_ == RADIO)
     value->SetBoolean(kCheckedKey, checked_);
@@ skipping 35 matching lines @@
   bool enabled = true;
   if (!value.GetBoolean(kEnabledKey, &enabled))
     return NULL;
   ContextList contexts;
   const base::Value* contexts_value = NULL;
   if (!value.Get(kContextsKey, &contexts_value))
     return NULL;
   if (!contexts.Populate(*contexts_value))
     return NULL;
 
-  scoped_ptr<MenuItem> result(new MenuItem(
-      id, title, checked, enabled, type, contexts));
+  std::unique_ptr<MenuItem> result(
+      new MenuItem(id, title, checked, enabled, type, contexts));
 
   std::vector<std::string> document_url_patterns;
   if (!GetStringList(value, kDocumentURLPatternsKey, &document_url_patterns))
     return NULL;
   std::vector<std::string> target_url_patterns;
   if (!GetStringList(value, kTargetURLPatternsKey, &target_url_patterns))
     return NULL;
 
   if (!result->PopulateURLPatterns(&document_url_patterns,
                                    &target_url_patterns,
                                    error)) {
     return NULL;
   }
 
   // parent_id is filled in from the value, but it might not be valid. It's left
   // to be validated upon being added (via AddChildItem) to the menu manager.
-  scoped_ptr<Id> parent_id(
+  std::unique_ptr<Id> parent_id(
       new Id(incognito, MenuItem::ExtensionKey(extension_id)));
   if (value.HasKey(kParentUIDKey)) {
     if (!value.GetString(kParentUIDKey, &parent_id->string_uid))
       return NULL;
     result->parent_id_.swap(parent_id);
   }
   return result.release();
 }
 
 bool MenuItem::PopulateURLPatterns(
@@ skipping 345 matching lines @@
   if (!item)
     return;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
   const Extension* extension =
       registry->enabled_extensions().GetByID(item->extension_id());
 
   if (item->type() == MenuItem::RADIO)
     RadioItemSelected(item);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
 
   base::DictionaryValue* properties = new base::DictionaryValue();
   SetIdKeyValue(properties, "menuItemId", item->id());
   if (item->parent_id())
     SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
 
   switch (params.media_type) {
     case blink::WebContextMenuData::MediaTypeImage:
       properties->SetString("mediaType", "image");
       break;
@@ skipping 62 matching lines @@
   // Note: web_contents are NULL in unit tests :(
   if (web_contents && TabHelper::FromWebContents(web_contents)) {
     TabHelper::FromWebContents(web_contents)
         ->active_tab_permission_granter()
         ->GrantIfRequested(extension);
   }
 
   {
     // Dispatch to menu item's .onclick handler (this is the legacy API, from
     // before chrome.contextMenus.onClicked existed).
-    scoped_ptr<Event> event(
+    std::unique_ptr<Event> event(
         new Event(webview_guest ? events::WEB_VIEW_INTERNAL_CONTEXT_MENUS
                                 : events::CONTEXT_MENUS,
                   webview_guest ? kOnWebviewContextMenus : kOnContextMenus,
-                  scoped_ptr<base::ListValue>(args->DeepCopy())));
+                  std::unique_ptr<base::ListValue>(args->DeepCopy())));
     event->restrict_to_browser_context = context;
     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
     event_router->DispatchEventToExtension(item->extension_id(),
                                            std::move(event));
   }
   {
     // Dispatch to .contextMenus.onClicked handler.
-    scoped_ptr<Event> event(new Event(
+    std::unique_ptr<Event> event(new Event(
         webview_guest ? events::CHROME_WEB_VIEW_INTERNAL_ON_CLICKED
                       : events::CONTEXT_MENUS_ON_CLICKED,
         webview_guest ? api::chrome_web_view_internal::OnClicked::kEventName
                       : api::context_menus::OnClicked::kEventName,
         std::move(args)));
     event->restrict_to_browser_context = context;
     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
     if (webview_guest)
       event->filter_info.SetInstanceID(webview_guest->view_instance_id());
     event_router->DispatchEventToExtension(item->extension_id(),
@@ skipping 74 matching lines @@
     }
   }
 
   if (store_) {
     store_->SetExtensionValue(extension->id(), kContextMenusKey,
                               MenuItemsToValue(all_items));
   }
 }
 
 void MenuManager::ReadFromStorage(const std::string& extension_id,
-                                  scoped_ptr<base::Value> value) {
+                                  std::unique_ptr<base::Value> value) {
   const Extension* extension = ExtensionRegistry::Get(browser_context_)
                                    ->enabled_extensions()
                                    .GetByID(extension_id);
   if (!extension)
     return;
 
   MenuItem::List items = MenuItemsFromValue(extension_id, value.get());
   for (size_t i = 0; i < items.size(); ++i) {
     bool added = false;
 
     if (items[i]->parent_id()) {
       // Parent IDs are stored in the parent_id field for convenience, but
       // they have not yet been validated. Separate them out here.
       // Because of the order in which we store items in the prefs, parents will
       // precede children, so we should already know about any parent items.
-      scoped_ptr<MenuItem::Id> parent_id;
+      std::unique_ptr<MenuItem::Id> parent_id;
       parent_id.swap(items[i]->parent_id_);
       added = AddChildItem(*parent_id, items[i]);
     } else {
       added = AddContextItem(extension, items[i]);
     }
 
     if (!added)
       delete items[i];
   }
 }
@@ skipping 130 matching lines @@
 bool MenuItem::Id::operator!=(const Id& other) const {
   return !(*this == other);
 }
 
 bool MenuItem::Id::operator<(const Id& other) const {
   return std::tie(incognito, extension_key, uid, string_uid) <
     std::tie(other.incognito, other.extension_key, other.uid, other.string_uid);
 }
 
 }  // namespace extensions