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

chrome/browser/ui/extensions/extension_installed_bubble.cc

 // Copyright 2013 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/ui/extensions/extension_installed_bubble.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/sync/sync_promo_ui.h"
@@ skipping 18 matching lines @@
 const int kAnimationWaitMs = 50;
 // How often we retry when waiting for browser action animation to end.
 const int kAnimationWaitRetries = 10;
 
 // Class responsible for showing the bubble after it's installed. Owns itself.
 class ExtensionInstalledBubbleObserver
     : public content::NotificationObserver,
       public extensions::ExtensionRegistryObserver {
  public:
   explicit ExtensionInstalledBubbleObserver(
-      scoped_ptr<ExtensionInstalledBubble> bubble)
+      std::unique_ptr<ExtensionInstalledBubble> bubble)
       : bubble_(std::move(bubble)),
         extension_registry_observer_(this),
         animation_wait_retries_(0),
         weak_factory_(this) {
     // |extension| has been initialized but not loaded at this point. We need to
     // wait on showing the Bubble until the EXTENSION_LOADED gets fired.
     extension_registry_observer_.Add(
         extensions::ExtensionRegistry::Get(bubble_->browser()->profile()));
 
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSING,
@@ skipping 65 matching lines @@
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kAnimationWaitMs));
     } else {
       // Retries are over; won't try again.
       // TODO(hcarmona): Look into logging this with the BubbleManager.
       delete this;
     }
   }
 
   // The bubble that will be shown when the extension has finished installing.
-  scoped_ptr<ExtensionInstalledBubble> bubble_;
+  std::unique_ptr<ExtensionInstalledBubble> bubble_;
 
   ScopedObserver<extensions::ExtensionRegistry,
                  extensions::ExtensionRegistryObserver>
       extension_registry_observer_;
 
   content::NotificationRegistrar registrar_;
 
   // The number of times to retry showing the bubble if the bubble_->browser()
   // action toolbar is animating.
   int animation_wait_retries_;
 
   base::WeakPtrFactory<ExtensionInstalledBubbleObserver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionInstalledBubbleObserver);
 };
 
 // Returns the keybinding for an extension command, or a null if none exists.
-scoped_ptr<extensions::Command> GetCommand(
+std::unique_ptr<extensions::Command> GetCommand(
     const std::string& extension_id,
     Profile* profile,
     ExtensionInstalledBubble::BubbleType type) {
-  scoped_ptr<extensions::Command> result;
+  std::unique_ptr<extensions::Command> result;
   extensions::Command command;
   extensions::CommandService* command_service =
       extensions::CommandService::Get(profile);
   bool has_command = false;
   if (type == ExtensionInstalledBubble::BROWSER_ACTION) {
     has_command = command_service->GetBrowserActionCommand(
         extension_id, extensions::CommandService::ACTIVE, &command, nullptr);
   } else if (type == ExtensionInstalledBubble::PAGE_ACTION) {
     has_command = command_service->GetPageActionCommand(
         extension_id, extensions::CommandService::ACTIVE, &command, nullptr);
   }
   if (has_command)
     result.reset(new extensions::Command(command));
   return result;
 }
 
 }  // namespace
 
 // static
 void ExtensionInstalledBubble::ShowBubble(
     const extensions::Extension* extension,
     Browser* browser,
     const SkBitmap& icon) {
   // The ExtensionInstalledBubbleObserver will delete itself when the
   // ExtensionInstalledBubble is shown or when it can't be shown anymore.
   auto x = new ExtensionInstalledBubbleObserver(
-      make_scoped_ptr(new ExtensionInstalledBubble(extension, browser, icon)));
+      base::WrapUnique(new ExtensionInstalledBubble(extension, browser, icon)));
   extensions::ExtensionRegistry* reg =
       extensions::ExtensionRegistry::Get(browser->profile());
   if (reg->enabled_extensions().GetByID(extension->id())) {
     x->Run();
   }
 }
 
 ExtensionInstalledBubble::ExtensionInstalledBubble(const Extension* extension,
                                                    Browser* browser,
                                                    const SkBitmap& icon)
@@ skipping 102 matching lines @@
       break;
     case OMNIBOX_KEYWORD:
       options_ |= HOW_TO_USE | HOW_TO_MANAGE;
       anchor_position_ = ANCHOR_OMNIBOX;
       break;
     case GENERIC:
       anchor_position_ = ANCHOR_APP_MENU;
       break;
   }
 }