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

chrome/browser/ui/extensions/extension_action_view_controller.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/ui/extensions/extension_action_view_controller.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 264 matching lines @@
 
   CommandService* command_service = CommandService::Get(browser_->profile());
   if (extension_action_->action_type() == ActionInfo::TYPE_PAGE) {
     return command_service->GetPageActionCommand(
         extension_->id(), CommandService::ACTIVE, command, NULL);
   }
   return command_service->GetBrowserActionCommand(
       extension_->id(), CommandService::ACTIVE, command, NULL);
 }
 
-scoped_ptr<IconWithBadgeImageSource>
+std::unique_ptr<IconWithBadgeImageSource>
 ExtensionActionViewController::GetIconImageSourceForTesting(
     content::WebContents* web_contents,
     const gfx::Size& size) {
   return GetIconImageSource(web_contents, size);
 }
 
 ExtensionActionViewController*
 ExtensionActionViewController::GetPreferredPopupViewController() {
   if (toolbar_actions_bar_ && toolbar_actions_bar_->in_overflow_mode()) {
     return static_cast<ExtensionActionViewController*>(
@@ skipping 15 matching lines @@
   // Always hide the current popup, even if it's not owned by this extension.
   // Only one popup should be visible at a time.
   HideActivePopup();
 
   // If we were showing a popup already, then we treat the action to open the
   // same one as a desire to close it (like clicking a menu button that was
   // already open).
   if (already_showing)
     return false;
 
-  scoped_ptr<extensions::ExtensionViewHost> host(
+  std::unique_ptr<extensions::ExtensionViewHost> host(
       extensions::ExtensionViewHostFactory::CreatePopupHost(popup_url,
                                                             browser_));
   if (!host)
     return false;
 
   popup_host_ = host.get();
   popup_host_observer_.Add(popup_host_);
   if (toolbar_actions_bar_)
     toolbar_actions_bar_->SetPopupOwner(this);
 
   if (toolbar_actions_bar_ &&
       !toolbar_actions_bar_->IsActionVisibleOnMainBar(this) &&
       extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()) {
     platform_delegate_->CloseOverflowMenu();
     toolbar_actions_bar_->PopOutAction(
         this,
         show_action == SHOW_POPUP_AND_INSPECT,
         base::Bind(&ExtensionActionViewController::ShowPopup,
                    weak_factory_.GetWeakPtr(), base::Passed(std::move(host)),
                    grant_tab_permissions, show_action));
   } else {
     ShowPopup(std::move(host), grant_tab_permissions, show_action);
   }
 
   return true;
 }
 
 void ExtensionActionViewController::ShowPopup(
-    scoped_ptr<extensions::ExtensionViewHost> popup_host,
+    std::unique_ptr<extensions::ExtensionViewHost> popup_host,
     bool grant_tab_permissions,
     PopupShowAction show_action) {
   // It's possible that the popup should be closed before it finishes opening
   // (since it can open asynchronously). Check before proceeding.
   if (!popup_host_)
     return;
   platform_delegate_->ShowPopup(std::move(popup_host), grant_tab_permissions,
                                 show_action);
   view_delegate_->OnPopupShown(grant_tab_permissions);
 }
 
 void ExtensionActionViewController::OnPopupClosed() {
   popup_host_observer_.Remove(popup_host_);
   popup_host_ = nullptr;
   if (toolbar_actions_bar_) {
     toolbar_actions_bar_->SetPopupOwner(nullptr);
     if (toolbar_actions_bar_->popped_out_action() == this &&
         !view_delegate_->IsMenuRunning())
       toolbar_actions_bar_->UndoPopOut();
   }
   view_delegate_->OnPopupClosed();
 }
 
-scoped_ptr<IconWithBadgeImageSource>
+std::unique_ptr<IconWithBadgeImageSource>
 ExtensionActionViewController::GetIconImageSource(
     content::WebContents* web_contents,
     const gfx::Size& size) {
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  scoped_ptr<IconWithBadgeImageSource> image_source(
+  std::unique_ptr<IconWithBadgeImageSource> image_source(
       new IconWithBadgeImageSource(size));
 
   image_source->SetIcon(icon_factory_.GetIcon(tab_id));
 
-  scoped_ptr<IconWithBadgeImageSource::Badge> badge;
+  std::unique_ptr<IconWithBadgeImageSource::Badge> badge;
   std::string badge_text = extension_action_->GetBadgeText(tab_id);
   if (!badge_text.empty()) {
     badge.reset(new IconWithBadgeImageSource::Badge(
             badge_text,
             extension_action_->GetBadgeTextColor(tab_id),
             extension_action_->GetBadgeBackgroundColor(tab_id)));
   }
   image_source->SetBadge(std::move(badge));
 
   // Greyscaling disabled actions and having a special wants-to-run decoration
@@ skipping 26 matching lines @@
          extension_action_->GetIsVisible(
              SessionTabHelper::IdForTab(web_contents));
 }
 
 bool ExtensionActionViewController::HasBeenBlocked(
     content::WebContents* web_contents) const {
   ExtensionActionRunner* action_runner =
       ExtensionActionRunner::GetForWebContents(web_contents);
   return action_runner && action_runner->WantsToRun(extension());
 }