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

chrome/browser/extensions/menu_manager_unittest.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 <memory>
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
-#include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/api/context_menus.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/prefs/pref_service.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 60 matching lines @@
   Extension* AddExtension(const std::string& name) {
     scoped_refptr<Extension> extension = prefs_.AddExtension(name);
     extensions_.push_back(extension);
     return extension.get();
   }
 
  protected:
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<TestingProfile> profile_;
 
   MenuManager manager_;
   ExtensionList extensions_;
   TestExtensionPrefs prefs_;
   int next_id_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MenuManagerTest);
 };
 
@@ skipping 30 matching lines @@
   ASSERT_EQ(NULL, manager_.GetItemById(id3));
   ASSERT_EQ(2u, manager_.MenuItems(extension_key3)->size());
 
   // Make sure removing a non-existent item returns false.
   const MenuItem::ExtensionKey key(extension->id());
   MenuItem::Id id(false, key);
   id.uid = id3.uid + 50;
   ASSERT_FALSE(manager_.RemoveContextMenuItem(id));
 
   // Make sure adding an item with the same string ID returns false.
-  scoped_ptr<MenuItem> item2too(CreateTestItemWithID(extension, "id2"));
+  std::unique_ptr<MenuItem> item2too(CreateTestItemWithID(extension, "id2"));
   ASSERT_FALSE(manager_.AddContextItem(extension, item2too.get()));
 
   // But the same string ID should not collide with another extension.
   Extension* extension2 = AddExtension("test2");
   MenuItem* item2other = CreateTestItemWithID(extension2, "id2");
   ASSERT_TRUE(manager_.AddContextItem(extension2, item2other));
 }
 
 // Test adding/removing child items.
 TEST_F(MenuManagerTest, ChildFunctions) {
   Extension* extension1 = AddExtension("1111");
   Extension* extension2 = AddExtension("2222");
   Extension* extension3 = AddExtension("3333");
 
   MenuItem* item1 = CreateTestItem(extension1);
   MenuItem* item2 = CreateTestItem(extension2);
   MenuItem* item2_child = CreateTestItemWithID(extension2, "2child");
   MenuItem* item2_grandchild = CreateTestItem(extension2);
 
   // This third item we expect to fail inserting, so we use a scoped_ptr to make
   // sure it gets deleted.
-  scoped_ptr<MenuItem> item3(CreateTestItem(extension3));
+  std::unique_ptr<MenuItem> item3(CreateTestItem(extension3));
 
   // Add in the first two items.
   ASSERT_TRUE(manager_.AddContextItem(extension1, item1));
   ASSERT_TRUE(manager_.AddContextItem(extension2, item2));
 
   MenuItem::Id id1 = item1->id();
   MenuItem::Id id2 = item2->id();
 
   // Try adding item3 as a child of item2 - this should fail because item3 has
   // a different extension id.
@@ skipping 59 matching lines @@
   value.SetString("string_uid", std::string());
   value.SetInteger("type", type);
   value.SetString("title", title);
   value.SetBoolean("checked", checked);
   value.SetBoolean("enabled", enabled);
   value.SetInteger("contexts", contexts_value);
   value.Set("document_url_patterns", document_url_patterns);
   value.Set("target_url_patterns", target_url_patterns);
 
   std::string error;
-  scoped_ptr<MenuItem> item(MenuItem::Populate(extension->id(), value, &error));
+  std::unique_ptr<MenuItem> item(
+      MenuItem::Populate(extension->id(), value, &error));
   ASSERT_TRUE(item.get());
 
   EXPECT_EQ(extension->id(), item->extension_id());
   EXPECT_EQ(incognito, item->incognito());
   EXPECT_EQ(title, item->title());
   EXPECT_EQ(checked, item->checked());
   EXPECT_EQ(item->checked(), item->checked());
   EXPECT_EQ(enabled, item->enabled());
   EXPECT_EQ(contexts, item->contexts());
 
@@ skipping 202 matching lines @@
 
   MOCK_METHOD6(DispatchEventToExtensionMock,
                void(const std::string& extension_id,
                     const std::string& event_name,
                     base::ListValue* event_args,
                     content::BrowserContext* source_context,
                     const GURL& event_url,
                     EventRouter::UserGestureState state));
 
   virtual void DispatchEventToExtension(const std::string& extension_id,
-                                        scoped_ptr<Event> event) {
+                                        std::unique_ptr<Event> event) {
     DispatchEventToExtensionMock(extension_id,
                                  event->event_name,
                                  event->event_args.release(),
                                  event->restrict_to_browser_context,
                                  event->event_url,
                                  event->user_gesture);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockEventRouter);
 };
 
 // MockEventRouter factory function
-scoped_ptr<KeyedService> MockEventRouterFactoryFunction(
+std::unique_ptr<KeyedService> MockEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new MockEventRouter(static_cast<Profile*>(context)));
+  return base::WrapUnique(new MockEventRouter(static_cast<Profile*>(context)));
 }
 
 }  // namespace
 
 // Tests the RemoveAll functionality.
 TEST_F(MenuManagerTest, RemoveAll) {
   // Try removing all items for an extension id that doesn't have any items.
   manager_.RemoveAllContextItems(MenuItem::ExtensionKey("CCCC"));
 
   // Add 2 top-level and one child item for extension 1.
@@ skipping 246 matching lines @@
   EXPECT_EQ(4u, manager_.MenuItems(key1)->size());
   EXPECT_EQ(1u, manager_.MenuItems(key2)->size());
 
   // Remove all context menu items with incognito true.
   manager_.RemoveAllIncognitoContextItems();
   EXPECT_EQ(2u, manager_.MenuItems(key1)->size());
   EXPECT_EQ(1u, manager_.MenuItems(key2)->size());
 }
 
 }  // namespace extensions