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

chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.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/webui/local_discovery/local_discovery_ui_handler.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/printing/cloud_print/privet_confirm_api_flow.h"
 #include "chrome/browser/printing/cloud_print/privet_constants.h"
 #include "chrome/browser/printing/cloud_print/privet_device_lister_impl.h"
@@ skipping 33 matching lines @@
 const char kDictionaryKeyType[] = "type";
 const char kDictionaryKeyIsWifi[] = "is_wifi";
 const char kDictionaryKeyID[] = "id";
 
 const char kKeyPrefixMDns[] = "MDns:";
 
 int g_num_visible = 0;
 
 const int kCloudDevicesPrivetVersion = 3;
 
-scoped_ptr<base::DictionaryValue> CreateDeviceInfo(
+std::unique_ptr<base::DictionaryValue> CreateDeviceInfo(
     const CloudPrintPrinterList::Device& description) {
-  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> return_value(
+      new base::DictionaryValue);
 
   return_value->SetString(kDictionaryKeyID, description.id);
   return_value->SetString(kDictionaryKeyDisplayName, description.display_name);
   return_value->SetString(kDictionaryKeyDescription, description.description);
   return_value->SetString(kDictionaryKeyType, "printer");
 
   return return_value;
 }
 
 void ReadDevicesList(const CloudPrintPrinterList::DeviceList& devices,
@@ skipping 157 matching lines @@
 void LocalDiscoveryUIHandler::HandleRequestDeviceList(
     const base::ListValue* args) {
   failed_list_count_ = 0;
   succeded_list_count_ = 0;
   cloud_devices_.clear();
 
   cloud_print_printer_list_ = CreateApiFlow();
 
   if (cloud_print_printer_list_) {
     cloud_print_printer_list_->Start(
-        make_scoped_ptr<GCDApiFlow::Request>(new CloudPrintPrinterList(this)));
+        base::WrapUnique<GCDApiFlow::Request>(new CloudPrintPrinterList(this)));
   }
 
   CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::HandleOpenCloudPrintURL(
     const base::ListValue* args) {
   std::string id;
   bool rv = args->GetString(0, &id);
   DCHECK(rv);
@@ skipping 10 matching lines @@
 void LocalDiscoveryUIHandler::HandleShowSyncUI(
     const base::ListValue* args) {
   Browser* browser = chrome::FindBrowserWithWebContents(
       web_ui()->GetWebContents());
   DCHECK(browser);
   chrome::ShowBrowserSignin(
       browser, signin_metrics::AccessPoint::ACCESS_POINT_DEVICES_PAGE);
 }
 
 void LocalDiscoveryUIHandler::StartRegisterHTTP(
-    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
+    std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
   current_http_client_ =
       cloud_print::PrivetV1HTTPClient::CreateDefault(std::move(http_client));
 
   std::string user = GetSyncAccount();
 
   if (!current_http_client_) {
     SendRegisterError();
     return;
   }
 
@@ skipping 11 matching lines @@
   if (device_descriptions_.count(current_http_client_->GetName()) == 0) {
     SendRegisterError();
     return;
   }
 
   confirm_api_call_flow_ = CreateApiFlow();
   if (!confirm_api_call_flow_) {
     SendRegisterError();
     return;
   }
-  confirm_api_call_flow_->Start(
-      make_scoped_ptr<GCDApiFlow::Request>(
-          new cloud_print::PrivetConfirmApiCallFlow(
-              token,
-              base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
-                         base::Unretained(this)))));
+  confirm_api_call_flow_->Start(base::WrapUnique<GCDApiFlow::Request>(
+      new cloud_print::PrivetConfirmApiCallFlow(
+          token, base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
+                            base::Unretained(this)))));
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterError(
     PrivetRegisterOperation* operation,
     const std::string& action,
     PrivetRegisterOperation::FailureReason reason,
     int printer_http_code,
     const base::DictionaryValue* json) {
   std::string error;
 
@@ skipping 49 matching lines @@
   if (description.id.empty()) {
     info.SetString(kDictionaryKeyServiceName, name);
     info.SetString(kDictionaryKeyDisplayName, description.name);
     info.SetString(kDictionaryKeyDescription, description.description);
     info.SetString(kDictionaryKeyType, description.type);
     info.SetBoolean(kDictionaryKeyIsWifi, false);
 
     web_ui()->CallJavascriptFunction(
         "local_discovery.onUnregisteredDeviceUpdate", service_key, info);
   } else {
-    scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
+    std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
 
     web_ui()->CallJavascriptFunction(
         "local_discovery.onUnregisteredDeviceUpdate", service_key, *null_value);
   }
 }
 
 void LocalDiscoveryUIHandler::DeviceRemoved(const std::string& name) {
   device_descriptions_.erase(name);
-  scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
+  std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   base::StringValue name_value(kKeyPrefixMDns + name);
 
   web_ui()->CallJavascriptFunction("local_discovery.onUnregisteredDeviceUpdate",
                                    name_value, *null_value);
 }
 
 void LocalDiscoveryUIHandler::DeviceCacheFlushed() {
   web_ui()->CallJavascriptFunction("local_discovery.onDeviceCacheFlushed");
   privet_lister_->DiscoverNewDevices(false);
 }
@@ skipping 115 matching lines @@
     local_ids.insert(i->second.id);
   }
 
   ReadDevicesList(cloud_devices_, local_ids, &devices_list);
 
   web_ui()->CallJavascriptFunction(
       "local_discovery.onCloudDeviceListAvailable", devices_list);
   cloud_print_printer_list_.reset();
 }
 
-scoped_ptr<GCDApiFlow> LocalDiscoveryUIHandler::CreateApiFlow() {
+std::unique_ptr<GCDApiFlow> LocalDiscoveryUIHandler::CreateApiFlow() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
-    return scoped_ptr<GCDApiFlow>();
+    return std::unique_ptr<GCDApiFlow>();
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   if (!token_service)
-    return scoped_ptr<GCDApiFlow>();
+    return std::unique_ptr<GCDApiFlow>();
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetInstance()->GetForProfile(profile);
   if (!signin_manager)
-    return scoped_ptr<GCDApiFlow>();
+    return std::unique_ptr<GCDApiFlow>();
   return GCDApiFlow::Create(profile->GetRequestContext(),
                             token_service,
                             signin_manager->GetAuthenticatedAccountId());
 }
 
 bool LocalDiscoveryUIHandler::IsUserSupervisedOrOffTheRecord() {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   return profile->IsSupervised() || profile->IsOffTheRecord();
 }
@@ skipping 100 matching lines @@
 
 void LocalDiscoveryUIHandler::RefreshCloudPrintStatusFromService() {
   if (cloud_print_connector_ui_enabled_)
     CloudPrintProxyServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()))->
         RefreshStatusFromService();
 }
 
 #endif // cloud print connector option stuff
 
 }  // namespace local_discovery