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

extensions/browser/api/guest_view/web_view/web_view_internal_api.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 "extensions/browser/api/guest_view/web_view/web_view_internal_api.h"
 
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 248 matching lines @@
 }
 
 WebViewInternalCaptureVisibleRegionFunction::
     WebViewInternalCaptureVisibleRegionFunction()
     : is_guest_transparent_(false) {}
 
 bool WebViewInternalCaptureVisibleRegionFunction::RunAsyncSafe(
     WebViewGuest* guest) {
   using api::extension_types::ImageDetails;
 
-  scoped_ptr<web_view_internal::CaptureVisibleRegion::Params> params(
+  std::unique_ptr<web_view_internal::CaptureVisibleRegion::Params> params(
       web_view_internal::CaptureVisibleRegion::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  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);
   }
 
   is_guest_transparent_ = guest->allow_transparency();
   return CaptureAsync(guest->web_contents(), image_details.get(),
                       base::Bind(&WebViewInternalCaptureVisibleRegionFunction::
                                      CopyFromBackingStoreComplete,
@@ skipping 33 matching lines @@
     case FAILURE_REASON_VIEW_INVISIBLE:
       reason_description = "view is invisible";
       break;
   }
   error_ = ErrorUtils::FormatErrorMessage("Failed to capture webview: *",
                                           reason_description);
   SendResponse(false);
 }
 
 bool WebViewInternalNavigateFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::Navigate::Params> params(
+  std::unique_ptr<web_view_internal::Navigate::Params> params(
       web_view_internal::Navigate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   std::string src = params->src;
   guest->NavigateGuest(src, true /* force_navigation */);
   return true;
 }
 
 WebViewInternalExecuteCodeFunction::WebViewInternalExecuteCodeFunction()
     : guest_instance_id_(0), guest_src_(GURL::EmptyGURL()) {
 }
@@ skipping 17 matching lines @@
 
   // Set |guest_src_| here, but do not return false if it is invalid.
   // Instead, let it continue with the normal page load sequence,
   // which will result in the usual LOAD_ABORT event in the case where
   // the URL is invalid.
   guest_src_ = GURL(src);
 
   base::DictionaryValue* details_value = NULL;
   if (!args_->GetDictionary(2, &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;
 
   details_ = std::move(details);
 
   if (extension()) {
     set_host_id(HostID(HostID::EXTENSIONS, extension()->id()));
     return true;
   }
 
@@ skipping 93 matching lines @@
 WebViewInternalAddContentScriptsFunction::
     WebViewInternalAddContentScriptsFunction() {
 }
 
 WebViewInternalAddContentScriptsFunction::
     ~WebViewInternalAddContentScriptsFunction() {
 }
 
 ExecuteCodeFunction::ResponseAction
 WebViewInternalAddContentScriptsFunction::Run() {
-  scoped_ptr<web_view_internal::AddContentScripts::Params> params(
+  std::unique_ptr<web_view_internal::AddContentScripts::Params> params(
       web_view_internal::AddContentScripts::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->instance_id)
     return RespondNow(Error(kViewInstanceIdError));
 
   GURL owner_base_url(
       render_frame_host()->GetSiteInstance()->GetSiteURL().GetWithEmptyPath());
   std::set<UserScript> result;
 
@@ skipping 19 matching lines @@
 WebViewInternalRemoveContentScriptsFunction::
     WebViewInternalRemoveContentScriptsFunction() {
 }
 
 WebViewInternalRemoveContentScriptsFunction::
     ~WebViewInternalRemoveContentScriptsFunction() {
 }
 
 ExecuteCodeFunction::ResponseAction
 WebViewInternalRemoveContentScriptsFunction::Run() {
-  scoped_ptr<web_view_internal::RemoveContentScripts::Params> params(
+  std::unique_ptr<web_view_internal::RemoveContentScripts::Params> params(
       web_view_internal::RemoveContentScripts::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->instance_id)
     return RespondNow(Error(kViewInstanceIdError));
 
   WebViewContentScriptManager* manager =
       WebViewContentScriptManager::Get(browser_context());
   DCHECK(manager);
 
   content::WebContents* sender_web_contents = GetSenderWebContents();
   HostID host_id = GenerateHostIDFromEmbedder(extension(), sender_web_contents);
 
   std::vector<std::string> script_name_list;
   if (params->script_name_list)
     script_name_list.swap(*params->script_name_list);
   manager->RemoveContentScripts(
       sender_web_contents->GetRenderProcessHost()->GetID(),
       params->instance_id, host_id, script_name_list);
   return RespondNow(NoArguments());
 }
 
 WebViewInternalSetNameFunction::WebViewInternalSetNameFunction() {
 }
 
 WebViewInternalSetNameFunction::~WebViewInternalSetNameFunction() {
 }
 
 bool WebViewInternalSetNameFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetName::Params> params(
+  std::unique_ptr<web_view_internal::SetName::Params> params(
       web_view_internal::SetName::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetName(params->frame_name);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 WebViewInternalSetAllowTransparencyFunction() {
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 ~WebViewInternalSetAllowTransparencyFunction() {
 }
 
 bool WebViewInternalSetAllowTransparencyFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetAllowTransparency::Params> params(
+  std::unique_ptr<web_view_internal::SetAllowTransparency::Params> params(
       web_view_internal::SetAllowTransparency::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetAllowTransparency(params->allow);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetAllowScalingFunction::
     WebViewInternalSetAllowScalingFunction() {
 }
 
 WebViewInternalSetAllowScalingFunction::
     ~WebViewInternalSetAllowScalingFunction() {
 }
 
 bool WebViewInternalSetAllowScalingFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetAllowScaling::Params> params(
+  std::unique_ptr<web_view_internal::SetAllowScaling::Params> params(
       web_view_internal::SetAllowScaling::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetAllowScaling(params->allow);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetZoomFunction::WebViewInternalSetZoomFunction() {
 }
 
 WebViewInternalSetZoomFunction::~WebViewInternalSetZoomFunction() {
 }
 
 bool WebViewInternalSetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetZoom::Params> params(
+  std::unique_ptr<web_view_internal::SetZoom::Params> params(
       web_view_internal::SetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetZoom(params->zoom_factor);
 
   SendResponse(true);
   return true;
 }
 
 WebViewInternalGetZoomFunction::WebViewInternalGetZoomFunction() {
 }
 
 WebViewInternalGetZoomFunction::~WebViewInternalGetZoomFunction() {
 }
 
 bool WebViewInternalGetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::GetZoom::Params> params(
+  std::unique_ptr<web_view_internal::GetZoom::Params> params(
       web_view_internal::GetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   double zoom_factor = guest->GetZoom();
   SetResult(new base::FundamentalValue(zoom_factor));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetZoomModeFunction::WebViewInternalSetZoomModeFunction() {
 }
 
 WebViewInternalSetZoomModeFunction::~WebViewInternalSetZoomModeFunction() {
 }
 
 bool WebViewInternalSetZoomModeFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetZoomMode::Params> params(
+  std::unique_ptr<web_view_internal::SetZoomMode::Params> params(
       web_view_internal::SetZoomMode::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ZoomController::ZoomMode zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
   switch (params->zoom_mode) {
     case web_view_internal::ZOOM_MODE_PER_ORIGIN:
       zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
       break;
     case web_view_internal::ZOOM_MODE_PER_VIEW:
       zoom_mode = ZoomController::ZOOM_MODE_ISOLATED;
@@ skipping 11 matching lines @@
   return true;
 }
 
 WebViewInternalGetZoomModeFunction::WebViewInternalGetZoomModeFunction() {
 }
 
 WebViewInternalGetZoomModeFunction::~WebViewInternalGetZoomModeFunction() {
 }
 
 bool WebViewInternalGetZoomModeFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::GetZoomMode::Params> params(
+  std::unique_ptr<web_view_internal::GetZoomMode::Params> params(
       web_view_internal::GetZoomMode::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   web_view_internal::ZoomMode zoom_mode = web_view_internal::ZOOM_MODE_NONE;
   switch (guest->GetZoomMode()) {
     case ZoomController::ZOOM_MODE_DEFAULT:
       zoom_mode = web_view_internal::ZOOM_MODE_PER_ORIGIN;
       break;
     case ZoomController::ZOOM_MODE_ISOLATED:
       zoom_mode = web_view_internal::ZOOM_MODE_PER_VIEW;
@@ skipping 10 matching lines @@
   return true;
 }
 
 WebViewInternalFindFunction::WebViewInternalFindFunction() {
 }
 
 WebViewInternalFindFunction::~WebViewInternalFindFunction() {
 }
 
 bool WebViewInternalFindFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::Find::Params> params(
+  std::unique_ptr<web_view_internal::Find::Params> params(
       web_view_internal::Find::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Convert the std::string search_text to string16.
   base::string16 search_text;
   base::UTF8ToUTF16(
       params->search_text.c_str(), params->search_text.length(), &search_text);
 
   // Set the find options to their default values.
   blink::WebFindOptions options;
   if (params->options) {
     options.forward =
         params->options->backward ? !*params->options->backward : true;
     options.matchCase =
         params->options->match_case ? *params->options->match_case : false;
   }
 
   guest->StartFind(search_text, options, this);
   return true;
 }
 
 WebViewInternalStopFindingFunction::WebViewInternalStopFindingFunction() {
 }
 
 WebViewInternalStopFindingFunction::~WebViewInternalStopFindingFunction() {
 }
 
 bool WebViewInternalStopFindingFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::StopFinding::Params> params(
+  std::unique_ptr<web_view_internal::StopFinding::Params> params(
       web_view_internal::StopFinding::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Set the StopFindAction.
   content::StopFindAction action;
   switch (params->action) {
     case web_view_internal::STOP_FINDING_ACTION_CLEAR:
       action = content::STOP_FIND_ACTION_CLEAR_SELECTION;
       break;
     case web_view_internal::STOP_FINDING_ACTION_KEEP:
@@ skipping 13 matching lines @@
 WebViewInternalLoadDataWithBaseUrlFunction::
     WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
 WebViewInternalLoadDataWithBaseUrlFunction::
     ~WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
 bool WebViewInternalLoadDataWithBaseUrlFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::LoadDataWithBaseUrl::Params> params(
+  std::unique_ptr<web_view_internal::LoadDataWithBaseUrl::Params> params(
       web_view_internal::LoadDataWithBaseUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // If a virtual URL was provided, use it. Otherwise, the user will be shown
   // the data URL.
   std::string virtual_url =
       params->virtual_url ? *params->virtual_url : params->data_url;
 
   bool successful = guest->LoadDataWithBaseURL(
       params->data_url, params->base_url, virtual_url, &error_);
   SendResponse(successful);
   return successful;
 }
 
 WebViewInternalGoFunction::WebViewInternalGoFunction() {
 }
 
 WebViewInternalGoFunction::~WebViewInternalGoFunction() {
 }
 
 bool WebViewInternalGoFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::Go::Params> params(
+  std::unique_ptr<web_view_internal::Go::Params> params(
       web_view_internal::Go::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool successful = guest->Go(params->relative_index);
   SetResult(new base::FundamentalValue(successful));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalReloadFunction::WebViewInternalReloadFunction() {
 }
 
 WebViewInternalReloadFunction::~WebViewInternalReloadFunction() {
 }
 
 bool WebViewInternalReloadFunction::RunAsyncSafe(WebViewGuest* guest) {
   guest->Reload();
   return true;
 }
 
 WebViewInternalSetPermissionFunction::WebViewInternalSetPermissionFunction() {
 }
 
 WebViewInternalSetPermissionFunction::~WebViewInternalSetPermissionFunction() {
 }
 
 bool WebViewInternalSetPermissionFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::SetPermission::Params> params(
+  std::unique_ptr<web_view_internal::SetPermission::Params> params(
       web_view_internal::SetPermission::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebViewPermissionHelper::PermissionResponseAction action =
       WebViewPermissionHelper::DEFAULT;
   switch (params->action) {
     case api::web_view_internal::SET_PERMISSION_ACTION_ALLOW:
       action = WebViewPermissionHelper::ALLOW;
       break;
     case api::web_view_internal::SET_PERMISSION_ACTION_DENY:
@@ skipping 28 matching lines @@
 WebViewInternalOverrideUserAgentFunction::
     WebViewInternalOverrideUserAgentFunction() {
 }
 
 WebViewInternalOverrideUserAgentFunction::
     ~WebViewInternalOverrideUserAgentFunction() {
 }
 
 bool WebViewInternalOverrideUserAgentFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<web_view_internal::OverrideUserAgent::Params> params(
+  std::unique_ptr<web_view_internal::OverrideUserAgent::Params> params(
       web_view_internal::OverrideUserAgent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   guest->SetUserAgentOverride(params->user_agent_override);
   return true;
 }
 
 WebViewInternalStopFunction::WebViewInternalStopFunction() {
 }
 
@@ skipping 92 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions