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

chrome/browser/extensions/extension_tab_util.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/extension_tab_util.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 313 matching lines @@
 
 std::string ExtensionTabUtil::GetTabStatusText(bool is_loading) {
   return is_loading ? keys::kStatusValueLoading : keys::kStatusValueComplete;
 }
 
 int ExtensionTabUtil::GetWindowIdOfTab(const WebContents* web_contents) {
   return SessionTabHelper::IdForWindowContainingTab(web_contents);
 }
 
 // static
-scoped_ptr<api::tabs::Tab> ExtensionTabUtil::CreateTabObject(
+std::unique_ptr<api::tabs::Tab> ExtensionTabUtil::CreateTabObject(
     WebContents* contents,
     TabStripModel* tab_strip,
     int tab_index,
     const Extension* extension) {
   // If we have a matching AppWindow with a controller, get the tab value
   // from its controller instead.
   WindowController* controller = GetAppWindowController(contents);
   if (controller &&
       (!extension || controller->IsVisibleToExtension(extension))) {
     return controller->CreateTabObject(extension, tab_index);
   }
-  scoped_ptr<api::tabs::Tab> result =
+  std::unique_ptr<api::tabs::Tab> result =
       CreateTabObject(contents, tab_strip, tab_index);
   ScrubTabForExtension(extension, contents, result.get());
   return result;
 }
 
 base::ListValue* ExtensionTabUtil::CreateTabList(
     const Browser* browser,
     const Extension* extension) {
   base::ListValue* tab_list = new base::ListValue();
   TabStripModel* tab_strip = browser->tab_strip_model();
   for (int i = 0; i < tab_strip->count(); ++i) {
     tab_list->Append(
         CreateTabObject(tab_strip->GetWebContentsAt(i), tab_strip, i, extension)
             ->ToValue()
             .release());
   }
 
   return tab_list;
 }
 
 // static
-scoped_ptr<api::tabs::Tab> ExtensionTabUtil::CreateTabObject(
+std::unique_ptr<api::tabs::Tab> ExtensionTabUtil::CreateTabObject(
     content::WebContents* contents,
     TabStripModel* tab_strip,
     int tab_index) {
   // If we have a matching AppWindow with a controller, get the tab value
   // from its controller instead.
   WindowController* controller = GetAppWindowController(contents);
   if (controller)
     return controller->CreateTabObject(nullptr, tab_index);
 
   if (!tab_strip)
     ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index);
   bool is_loading = contents->IsLoading();
-  scoped_ptr<api::tabs::Tab> tab_object(new api::tabs::Tab);
+  std::unique_ptr<api::tabs::Tab> tab_object(new api::tabs::Tab);
   tab_object->id.reset(new int(GetTabIdForExtensions(contents)));
   tab_object->index = tab_index;
   tab_object->window_id = GetWindowIdOfTab(contents);
   tab_object->status.reset(new std::string(GetTabStatusText(is_loading)));
   tab_object->active = tab_strip && tab_index == tab_strip->active_index();
   tab_object->selected = tab_strip && tab_index == tab_strip->active_index();
   tab_object->highlighted = tab_strip && tab_strip->IsTabSelected(tab_index);
   tab_object->pinned = tab_strip && tab_strip->IsTabPinned(tab_index);
   tab_object->audible.reset(new bool(contents->WasRecentlyAudible()));
   tab_object->muted_info = CreateMutedInfo(contents);
@@ skipping 13 matching lines @@
   if (tab_strip) {
     WebContents* opener = tab_strip->GetOpenerOfWebContentsAt(tab_index);
     if (opener)
       tab_object->opener_tab_id.reset(new int(GetTabIdForExtensions(opener)));
   }
 
   return tab_object;
 }
 
 // static
-scoped_ptr<api::tabs::MutedInfo> ExtensionTabUtil::CreateMutedInfo(
+std::unique_ptr<api::tabs::MutedInfo> ExtensionTabUtil::CreateMutedInfo(
     content::WebContents* contents) {
   DCHECK(contents);
-  scoped_ptr<api::tabs::MutedInfo> info(new api::tabs::MutedInfo);
+  std::unique_ptr<api::tabs::MutedInfo> info(new api::tabs::MutedInfo);
   info->muted = contents->IsAudioMuted();
   switch (chrome::GetTabAudioMutedReason(contents)) {
     case TabMutedReason::NONE:
       break;
     case TabMutedReason::CONTEXT_MENU:
     case TabMutedReason::AUDIO_INDICATOR:
       info->reason = api::tabs::MUTED_INFO_REASON_USER;
       break;
     case TabMutedReason::MEDIA_CAPTURE:
       info->reason = api::tabs::MUTED_INFO_REASON_CAPTURE;
@@ skipping 191 matching lines @@
   return NULL;
 }
 
 bool ExtensionTabUtil::OpenOptionsPage(const Extension* extension,
                                        Browser* browser) {
   if (!OptionsPageInfo::HasOptionsPage(extension))
     return false;
 
   // Force the options page to open in non-OTR window, because it won't be
   // able to save settings from OTR.
-  scoped_ptr<chrome::ScopedTabbedBrowserDisplayer> displayer;
+  std::unique_ptr<chrome::ScopedTabbedBrowserDisplayer> displayer;
   if (browser->profile()->IsOffTheRecord()) {
     displayer.reset(new chrome::ScopedTabbedBrowserDisplayer(
         browser->profile()->GetOriginalProfile()));
     browser = displayer->browser();
   }
 
   GURL url_to_navigate;
   bool open_in_tab = OptionsPageInfo::ShouldOpenInTab(extension);
   if (open_in_tab) {
     // Options page tab is simply e.g. chrome-extension://.../options.html.
@@ skipping 23 matching lines @@
   chrome::ShowSingletonTabOverwritingNTP(browser, params);
   return true;
 }
 
 // static
 bool ExtensionTabUtil::BrowserSupportsTabs(Browser* browser) {
   return browser && browser->tab_strip_model() && !browser->is_devtools();
 }
 
 }  // namespace extensions