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

chrome/browser/extensions/api/tabs/tabs_api.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/api/tabs/tabs_api.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <limits>
 #include <utility>
@@ skipping 184 matching lines @@
 }
 
 // Returns true if either |boolean| is a null pointer, or if |*boolean| and
 // |value| are equal. This function is used to check if a tab's parameters match
 // those of the browser.
 bool MatchesBool(bool* boolean, bool value) {
   return !boolean || *boolean == value;
 }
 
 template <typename T>
-void AssignOptionalValue(const scoped_ptr<T>& source,
-                         scoped_ptr<T>& destination) {
+void AssignOptionalValue(const std::unique_ptr<T>& source,
+                         std::unique_ptr<T>& destination) {
   if (source.get()) {
     destination.reset(new T(*source.get()));
   }
 }
 
 ui::WindowShowState ConvertToWindowShowState(windows::WindowState state) {
   switch (state) {
     case windows::WINDOW_STATE_NORMAL:
     case windows::WINDOW_STATE_DOCKED:
       return ui::SHOW_STATE_NORMAL;
@@ skipping 61 matching lines @@
     case ZoomController::ZOOM_MODE_DISABLED:
       zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_DISABLED;
       zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_TAB;
       break;
   }
 }
 
 // Windows ---------------------------------------------------------------------
 
 bool WindowsGetFunction::RunSync() {
-  scoped_ptr<windows::Get::Params> params(windows::Get::Params::Create(*args_));
+  std::unique_ptr<windows::Get::Params> params(
+      windows::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::Get::Params> extractor(params.get());
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(
           this, params->window_id, extractor.type_filters(), &controller)) {
     return false;
   }
 
   if (extractor.populate_tabs())
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetCurrentFunction::RunSync() {
-  scoped_ptr<windows::GetCurrent::Params> params(
+  std::unique_ptr<windows::GetCurrent::Params> params(
       windows::GetCurrent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetCurrent::Params> extractor(params.get());
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(
           this, extension_misc::kCurrentWindowId, extractor.type_filters(),
           &controller)) {
     return false;
   }
   if (extractor.populate_tabs())
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetLastFocusedFunction::RunSync() {
-  scoped_ptr<windows::GetLastFocused::Params> params(
+  std::unique_ptr<windows::GetLastFocused::Params> params(
       windows::GetLastFocused::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetLastFocused::Params> extractor(
       params.get());
   // The WindowControllerList should contain a list of application,
   // browser and devtools windows.
   WindowController* controller = nullptr;
   for (auto iter : WindowControllerList::GetInstance()->windows()) {
     if (windows_util::CanOperateOnWindow(this, iter,
                                          extractor.type_filters())) {
       controller = iter;
       if (controller->window()->IsActive())
         break;  // Use focused window.
     }
   }
   if (!controller) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
   if (extractor.populate_tabs())
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetAllFunction::RunSync() {
-  scoped_ptr<windows::GetAll::Params> params(
+  std::unique_ptr<windows::GetAll::Params> params(
       windows::GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetAll::Params> extractor(params.get());
   base::ListValue* window_list = new base::ListValue();
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
@@ skipping 51 matching lines @@
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
       *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
 bool WindowsCreateFunction::RunSync() {
-  scoped_ptr<windows::Create::Params> params(
+  std::unique_ptr<windows::Create::Params> params(
       windows::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::vector<GURL> urls;
   TabStripModel* source_tab_strip = NULL;
   int tab_index = -1;
 
   windows::Create::Params::CreateData* create_data = params->create_data.get();
 
   // Look for optional url.
   if (create_data && create_data->url) {
@@ skipping 254 matching lines @@
     // profile and CanCrossIncognito isn't allowed.
     SetResult(base::Value::CreateNullValue());
   } else {
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   }
 
   return true;
 }
 
 bool WindowsUpdateFunction::RunSync() {
-  scoped_ptr<windows::Update::Params> params(
+  std::unique_ptr<windows::Update::Params> params(
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(
           this, params->window_id, WindowController::GetAllWindowFilter(),
           &controller)) {
     return false;
   }
 
@@ skipping 83 matching lines @@
 
   if (params->update_info.draw_attention)
     controller->window()->FlashFrame(*params->update_info.draw_attention);
 
   SetResult(controller->CreateWindowValue());
 
   return true;
 }
 
 bool WindowsRemoveFunction::RunSync() {
-  scoped_ptr<windows::Remove::Params> params(
+  std::unique_ptr<windows::Remove::Params> params(
       windows::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                            WindowController::kNoWindowFilter,
                                            &controller)) {
     return false;
   }
 
   WindowController::Reason reason;
   if (!controller->CanClose(&reason)) {
     if (reason == WindowController::REASON_NOT_EDITABLE)
       error_ = keys::kTabStripNotEditableError;
     return false;
   }
   controller->window()->Close();
   return true;
 }
 
 // Tabs ------------------------------------------------------------------------
 
 bool TabsGetSelectedFunction::RunSync() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
-  scoped_ptr<tabs::GetSelected::Params> params(
+  std::unique_ptr<tabs::GetSelected::Params> params(
       tabs::GetSelected::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->window_id.get())
     window_id = *params->window_id;
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   TabStripModel* tab_strip = browser->tab_strip_model();
   WebContents* contents = tab_strip->GetActiveWebContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
   results_ = tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
       contents, tab_strip, tab_strip->active_index(), extension()));
   return true;
 }
 
 bool TabsGetAllInWindowFunction::RunSync() {
-  scoped_ptr<tabs::GetAllInWindow::Params> params(
+  std::unique_ptr<tabs::GetAllInWindow::Params> params(
       tabs::GetAllInWindow::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (params->window_id.get())
     window_id = *params->window_id;
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabList(browser, extension()));
 
   return true;
 }
 
 bool TabsQueryFunction::RunSync() {
-  scoped_ptr<tabs::Query::Params> params(tabs::Query::Params::Create(*args_));
+  std::unique_ptr<tabs::Query::Params> params(
+      tabs::Query::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool loading_status_set = params->query_info.status != tabs::TAB_STATUS_NONE;
   bool loading = params->query_info.status == tabs::TAB_STATUS_LOADING;
 
   URLPatternSet url_patterns;
   if (params->query_info.url.get()) {
     std::vector<std::string> url_pattern_strings;
     if (params->query_info.url->as_string)
       url_pattern_strings.push_back(*params->query_info.url->as_string);
@@ skipping 132 matching lines @@
                          ->ToValue()
                          .release());
     }
   }
 
   SetResult(result);
   return true;
 }
 
 bool TabsCreateFunction::RunSync() {
-  scoped_ptr<tabs::Create::Params> params(tabs::Create::Params::Create(*args_));
+  std::unique_ptr<tabs::Create::Params> params(
+      tabs::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionTabUtil::OpenTabParams options;
   AssignOptionalValue(params->create_properties.window_id, options.window_id);
   AssignOptionalValue(params->create_properties.opener_tab_id,
                       options.opener_tab_id);
   AssignOptionalValue(params->create_properties.selected, options.active);
   // The 'active' property has replaced the 'selected' property.
   AssignOptionalValue(params->create_properties.active, options.active);
   AssignOptionalValue(params->create_properties.pinned, options.pinned);
   AssignOptionalValue(params->create_properties.index, options.index);
   AssignOptionalValue(params->create_properties.url, options.url);
 
   std::string error;
-  scoped_ptr<base::DictionaryValue> result(
+  std::unique_ptr<base::DictionaryValue> result(
       ExtensionTabUtil::OpenTab(this, options, &error));
   if (!result) {
     SetError(error);
     return false;
   }
 
   // Return data about the newly created tab.
   if (has_callback()) {
     SetResult(result.release());
   }
   return true;
 }
 
 bool TabsDuplicateFunction::RunSync() {
-  scoped_ptr<tabs::Duplicate::Params> params(
+  std::unique_ptr<tabs::Duplicate::Params> params(
       tabs::Duplicate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->tab_id;
 
   Browser* browser = NULL;
   TabStripModel* tab_strip = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id,
                   GetProfile(),
                   include_incognito(),
@@ skipping 21 matching lines @@
   }
 
   // Return data about the newly created tab.
   results_ = tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
       new_contents, new_tab_strip, new_tab_index, extension()));
 
   return true;
 }
 
 bool TabsGetFunction::RunSync() {
-  scoped_ptr<tabs::Get::Params> params(tabs::Get::Params::Create(*args_));
+  std::unique_ptr<tabs::Get::Params> params(tabs::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->tab_id;
 
   TabStripModel* tab_strip = NULL;
   WebContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id,
                   GetProfile(),
                   include_incognito(),
                   NULL,
@@ skipping 15 matching lines @@
   // empty tab (hence returning true).
   WebContents* caller_contents = GetSenderWebContents();
   if (caller_contents && ExtensionTabUtil::GetTabId(caller_contents) >= 0)
     results_ = tabs::Get::Results::Create(
         *ExtensionTabUtil::CreateTabObject(caller_contents, extension()));
 
   return true;
 }
 
 bool TabsHighlightFunction::RunSync() {
-  scoped_ptr<tabs::Highlight::Params> params(
+  std::unique_ptr<tabs::Highlight::Params> params(
       tabs::Highlight::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Get the window id from the params; default to current window if omitted.
   int window_id = extension_misc::kCurrentWindowId;
   if (params->highlight_info.window_id.get())
     window_id = *params->highlight_info.window_id;
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
@@ skipping 49 matching lines @@
     *active_index = index;
 
   selection->AddIndexToSelection(index);
   return true;
 }
 
 TabsUpdateFunction::TabsUpdateFunction() : web_contents_(NULL) {
 }
 
 bool TabsUpdateFunction::RunAsync() {
-  scoped_ptr<tabs::Update::Params> params(tabs::Update::Params::Create(*args_));
+  std::unique_ptr<tabs::Update::Params> params(
+      tabs::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int tab_id = -1;
   WebContents* contents = NULL;
   if (!params->tab_id.get()) {
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
@@ skipping 180 matching lines @@
     const GURL& url,
     const base::ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
   SendResponse(error.empty());
 }
 
 bool TabsMoveFunction::RunSync() {
-  scoped_ptr<tabs::Move::Params> params(tabs::Move::Params::Create(*args_));
+  std::unique_ptr<tabs::Move::Params> params(
+      tabs::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int new_index = params->move_properties.index;
   int* window_id = params->move_properties.window_id.get();
-  scoped_ptr<base::ListValue> tab_values(new base::ListValue());
+  std::unique_ptr<base::ListValue> tab_values(new base::ListValue());
 
   size_t num_tabs = 0;
   if (params->tab_ids.as_integers) {
     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
     num_tabs = tab_ids.size();
     for (size_t i = 0; i < tab_ids.size(); ++i) {
       if (!MoveTab(tab_ids[i], &new_index, i, tab_values.get(), window_id))
         return false;
     }
   } else {
     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
     num_tabs = 1;
     if (!MoveTab(*params->tab_ids.as_integer,
                  &new_index,
                  0,
                  tab_values.get(),
                  window_id)) {
       return false;
     }
   }
 
   if (!has_callback())
     return true;
 
   if (num_tabs == 0) {
     error_ = "No tabs given.";
     return false;
   } else if (num_tabs == 1) {
-    scoped_ptr<base::Value> value;
+    std::unique_ptr<base::Value> value;
     CHECK(tab_values.get()->Remove(0, &value));
     SetResult(value.release());
   } else {
     // Only return the results as an array if there are multiple tabs.
     SetResult(tab_values.release());
   }
 
   return true;
 }
 
@@ skipping 94 matching lines @@
     tab_values->Append(ExtensionTabUtil::CreateTabObject(
                            contents, source_tab_strip, *new_index, extension())
                            ->ToValue()
                            .release());
   }
 
   return true;
 }
 
 bool TabsReloadFunction::RunSync() {
-  scoped_ptr<tabs::Reload::Params> params(
+  std::unique_ptr<tabs::Reload::Params> params(
       tabs::Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool bypass_cache = false;
   if (params->reload_properties.get() &&
       params->reload_properties->bypass_cache.get()) {
     bypass_cache = *params->reload_properties->bypass_cache;
   }
 
   content::WebContents* web_contents = NULL;
@@ skipping 35 matching lines @@
   } else if (bypass_cache) {
     web_contents->GetController().ReloadBypassingCache(true);
   } else {
     web_contents->GetController().Reload(true);
   }
 
   return true;
 }
 
 bool TabsRemoveFunction::RunSync() {
-  scoped_ptr<tabs::Remove::Params> params(tabs::Remove::Params::Create(*args_));
+  std::unique_ptr<tabs::Remove::Params> params(
+      tabs::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->tab_ids.as_integers) {
     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
     for (size_t i = 0; i < tab_ids.size(); ++i) {
       if (!RemoveTab(tab_ids[i]))
         return false;
     }
   } else {
     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
@@ skipping 70 matching lines @@
 }
 
 bool TabsCaptureVisibleTabFunction::RunAsync() {
   using api::extension_types::ImageDetails;
 
   EXTENSION_FUNCTION_VALIDATE(args_);
 
   int context_id = extension_misc::kCurrentWindowId;
   args_->GetInteger(0, &context_id);
 
-  scoped_ptr<ImageDetails> image_details;
+  std::unique_ptr<ImageDetails> image_details;
   if (args_->GetSize() > 1) {
     base::Value* spec = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->Get(1, &spec) && spec);
     image_details = ImageDetails::FromValue(*spec);
   }
 
   WebContents* contents = GetWebContentsForID(context_id);
 
   return CaptureAsync(
       contents, image_details.get(),
@@ skipping 29 matching lines @@
                                           reason_description);
   SendResponse(false);
 }
 
 void TabsCaptureVisibleTabFunction::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(prefs::kDisableScreenshots, false);
 }
 
 bool TabsDetectLanguageFunction::RunAsync() {
-  scoped_ptr<tabs::DetectLanguage::Params> params(
+  std::unique_ptr<tabs::DetectLanguage::Params> params(
       tabs::DetectLanguage::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int tab_id = 0;
   Browser* browser = NULL;
   WebContents* contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
   if (params->tab_id.get()) {
@@ skipping 101 matching lines @@
 
   // |tab_id| is optional so it's ok if it's not there.
   int tab_id = -1;
   if (args_->GetInteger(0, &tab_id))
     EXTENSION_FUNCTION_VALIDATE(tab_id >= 0);
 
   // |details| are not optional.
   base::DictionaryValue* details_value = NULL;
   if (!args_->GetDictionary(1, &details_value))
     return false;
-  scoped_ptr<InjectDetails> details(new InjectDetails());
+  std::unique_ptr<InjectDetails> details(new InjectDetails());
   if (!InjectDetails::Populate(*details_value, details.get()))
     return false;
 
   // If the tab ID wasn't given then it needs to be converted to the
   // currently active tab's ID.
   if (tab_id == -1) {
     Browser* browser = chrome_details_.GetCurrentBrowser();
     if (!browser)
       return false;
     content::WebContents* web_contents = NULL;
@@ skipping 132 matching lines @@
     Browser* browser = GetCurrentBrowser();
     if (!browser)
       error_ = keys::kNoCurrentWindowError;
     else if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
       error_ = keys::kNoSelectedTabError;
   }
   return web_contents;
 }
 
 bool TabsSetZoomFunction::RunAsync() {
-  scoped_ptr<tabs::SetZoom::Params> params(
+  std::unique_ptr<tabs::SetZoom::Params> params(
       tabs::SetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
     return false;
 
   GURL url(web_contents->GetVisibleURL());
   if (PermissionsData::IsRestrictedUrl(url, extension(), &error_))
@@ skipping 11 matching lines @@
     // Tried to zoom a tab in disabled mode.
     error_ = keys::kCannotZoomDisabledTabError;
     return false;
   }
 
   SendResponse(true);
   return true;
 }
 
 bool TabsGetZoomFunction::RunAsync() {
-  scoped_ptr<tabs::GetZoom::Params> params(
+  std::unique_ptr<tabs::GetZoom::Params> params(
       tabs::GetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
     return false;
 
   double zoom_level =
       ZoomController::FromWebContents(web_contents)->GetZoomLevel();
   double zoom_factor = content::ZoomLevelToZoomFactor(zoom_level);
   results_ = tabs::GetZoom::Results::Create(zoom_factor);
   SendResponse(true);
   return true;
 }
 
 bool TabsSetZoomSettingsFunction::RunAsync() {
   using api::tabs::ZoomSettings;
 
-  scoped_ptr<tabs::SetZoomSettings::Params> params(
+  std::unique_ptr<tabs::SetZoomSettings::Params> params(
       tabs::SetZoomSettings::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
     return false;
 
   GURL url(web_contents->GetVisibleURL());
   if (PermissionsData::IsRestrictedUrl(url, extension(), &error_))
@@ skipping 29 matching lines @@
       zoom_mode = ZoomController::ZOOM_MODE_DISABLED;
   }
 
   ZoomController::FromWebContents(web_contents)->SetZoomMode(zoom_mode);
 
   SendResponse(true);
   return true;
 }
 
 bool TabsGetZoomSettingsFunction::RunAsync() {
-  scoped_ptr<tabs::GetZoomSettings::Params> params(
+  std::unique_ptr<tabs::GetZoomSettings::Params> params(
       tabs::GetZoomSettings::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
     return false;
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(web_contents);
 
   ZoomController::ZoomMode zoom_mode = zoom_controller->zoom_mode();
   api::tabs::ZoomSettings zoom_settings;
   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
   zoom_settings.default_zoom_factor.reset(new double(
       content::ZoomLevelToZoomFactor(zoom_controller->GetDefaultZoomLevel())));
 
   results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions