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

chrome/browser/extensions/menu_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_
 #define CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/url_pattern_set.h"
@@ skipping 107 matching lines @@
     }
 
     bool Contains(Context context) const {
       return (value_ & context) > 0;
     }
 
     void Add(Context context) {
       value_ |= context;
     }
 
-    scoped_ptr<base::Value> ToValue() const {
-      return scoped_ptr<base::Value>(
+    std::unique_ptr<base::Value> ToValue() const {
+      return std::unique_ptr<base::Value>(
           new base::FundamentalValue(static_cast<int>(value_)));
     }
 
     bool Populate(const base::Value& value) {
       int int_value;
       if (!value.GetAsInteger(&int_value) || int_value < 0)
         return false;
       value_ = int_value;
       return true;
     }
@@ skipping 45 matching lines @@
 
   // Returns the title with any instances of %s replaced by |selection|. The
   // result will be no longer than |max_length|.
   base::string16 TitleWithReplacement(const base::string16& selection,
                                 size_t max_length) const;
 
   // Sets the checked state to |checked|. Returns true if successful.
   bool SetChecked(bool checked);
 
   // Converts to Value for serialization to preferences.
-  scoped_ptr<base::DictionaryValue> ToValue() const;
+  std::unique_ptr<base::DictionaryValue> ToValue() const;
 
   // Returns a new MenuItem created from |value|, or NULL if there is
   // an error. The caller takes ownership of the MenuItem.
   static MenuItem* Populate(const std::string& extension_id,
                             const base::DictionaryValue& value,
                             std::string* error);
 
   // Sets any document and target URL patterns from |properties|.
   bool PopulateURLPatterns(std::vector<std::string>* document_url_patterns,
                            std::vector<std::string>* target_url_patterns,
@@ skipping 30 matching lines @@
   bool checked_;
 
   // If the item is enabled or not.
   bool enabled_;
 
   // In what contexts should the item be shown?
   ContextList contexts_;
 
   // If this item is a child of another item, the unique id of its parent. If
   // this is a top-level item with no parent, this will be NULL.
-  scoped_ptr<Id> parent_id_;
+  std::unique_ptr<Id> parent_id_;
 
   // Patterns for restricting what documents this item will appear for. This
   // applies to the frame where the click took place.
   URLPatternSet document_url_patterns_;
 
   // Patterns for restricting where items appear based on the src/href
   // attribute of IMAGE/AUDIO/VIDEO/LINK tags.
   URLPatternSet target_url_patterns_;
 
   // Any children this item may have.
@@ skipping 86 matching lines @@
                            const Extension* extension,
                            UnloadedExtensionInfo::Reason reason) override;
 
   // Stores the menu items for the extension in the state storage.
   void WriteToStorage(const Extension* extension,
                       const MenuItem::ExtensionKey& extension_key);
 
   // Reads menu items for the extension from the state storage. Any invalid
   // items are ignored.
   void ReadFromStorage(const std::string& extension_id,
-                       scoped_ptr<base::Value> value);
+                       std::unique_ptr<base::Value> value);
 
   // Removes all "incognito" "split" mode context items.
   void RemoveAllIncognitoContextItems();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(MenuManagerTest, DeleteParent);
   FRIEND_TEST_ALL_PREFIXES(MenuManagerTest, RemoveOneByOne);
 
   // This is a helper function which takes care of de-selecting any other radio
   // items in the same group (i.e. that are adjacent in the list).
@@ skipping 29 matching lines @@
 
   // Owned by ExtensionSystem.
   StateStore* store_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuManager);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_