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

chrome/browser/ui/webui/print_preview/print_preview_handler.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/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
+
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/number_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
@@ skipping 141 matching lines @@
 
 // Id of the predefined PDF printer.
 const char kLocalPdfPrinterId[] = "Save as PDF";
 
 // Additional printer capability setting keys.
 const char kPrinterId[] = "printerId";
 const char kPrinterCapabilities[] = "capabilities";
 
 // Get the print job settings dictionary from |args|. The caller takes
 // ownership of the returned DictionaryValue. Returns NULL on failure.
-scoped_ptr<base::DictionaryValue> GetSettingsDictionary(
+std::unique_ptr<base::DictionaryValue> GetSettingsDictionary(
     const base::ListValue* args) {
   std::string json_str;
   if (!args->GetString(0, &json_str)) {
     NOTREACHED() << "Could not read JSON argument";
     return NULL;
   }
   if (json_str.empty()) {
     NOTREACHED() << "Empty print job settings";
     return NULL;
   }
-  scoped_ptr<base::DictionaryValue> settings =
+  std::unique_ptr<base::DictionaryValue> settings =
       base::DictionaryValue::From(base::JSONReader::Read(json_str));
   if (!settings) {
     NOTREACHED() << "Print job settings must be a dictionary.";
     return NULL;
   }
 
   if (settings->empty()) {
     NOTREACHED() << "Print job settings dictionary is empty";
     return NULL;
   }
@@ skipping 112 matching lines @@
  public:
   // PrintingContext::Delegate methods.
   gfx::NativeView GetParentView() override { return NULL; }
   std::string GetAppLocale() override {
     return g_browser_process->GetApplicationLocale();
   }
 };
 
 gfx::Size GetDefaultPdfMediaSizeMicrons() {
   PrintingContextDelegate delegate;
-  scoped_ptr<printing::PrintingContext> printing_context(
+  std::unique_ptr<printing::PrintingContext> printing_context(
       printing::PrintingContext::Create(&delegate));
   if (printing::PrintingContext::OK != printing_context->UsePdfSettings() ||
       printing_context->settings().device_units_per_inch() <= 0) {
     return gfx::Size();
   }
   gfx::Size pdf_media_size = printing_context->GetPdfPaperSizeDeviceUnits();
   float deviceMicronsPerDeviceUnit =
       (printing::kHundrethsMMPerInch * 10.0f) /
       printing_context->settings().device_units_per_inch();
   return gfx::Size(pdf_media_size.width() * deviceMicronsPerDeviceUnit,
                    pdf_media_size.height() * deviceMicronsPerDeviceUnit);
 }
 
 typedef base::Callback<void(const base::DictionaryValue*)>
     GetPdfCapabilitiesCallback;
 
-scoped_ptr<base::DictionaryValue> GetPdfCapabilitiesOnFileThread(
+std::unique_ptr<base::DictionaryValue> GetPdfCapabilitiesOnFileThread(
     const std::string& locale) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   cloud_devices::CloudDeviceDescription description;
   using namespace cloud_devices::printer;
 
   OrientationCapability orientation;
   orientation.AddOption(cloud_devices::printer::PORTRAIT);
   orientation.AddOption(cloud_devices::printer::LANDSCAPE);
   orientation.AddDefaultOption(AUTO_ORIENTATION, true);
@@ skipping 28 matching lines @@
     default_media = Media(locale == "en-US" ? NA_LETTER : ISO_A4);
   }
   MediaCapability media;
   for (size_t i = 0; i < arraysize(kPdfMedia); ++i) {
     Media media_option(kPdfMedia[i]);
     media.AddDefaultOption(media_option,
                            default_media.type == media_option.type);
   }
   media.SaveTo(&description);
 
-  return scoped_ptr<base::DictionaryValue>(description.root().DeepCopy());
+  return std::unique_ptr<base::DictionaryValue>(description.root().DeepCopy());
 }
 
-scoped_ptr<base::DictionaryValue> GetLocalPrinterCapabilitiesOnFileThread(
+std::unique_ptr<base::DictionaryValue> GetLocalPrinterCapabilitiesOnFileThread(
     const std::string& printer_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   scoped_refptr<printing::PrintBackend> print_backend(
       printing::PrintBackend::CreateInstance(NULL));
 
   VLOG(1) << "Get printer capabilities start for " << printer_name;
   crash_keys::ScopedPrinterInfo crash_key(
       print_backend->GetPrinterDriverInfo(printer_name));
 
   if (!print_backend->IsValidPrinter(printer_name)) {
     LOG(WARNING) << "Invalid printer " << printer_name;
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
   }
 
   printing::PrinterSemanticCapsAndDefaults info;
   if (!print_backend->GetPrinterSemanticCapsAndDefaults(printer_name, &info)) {
     LOG(WARNING) << "Failed to get capabilities for " << printer_name;
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
   }
 
-  scoped_ptr<base::DictionaryValue> description(
+  std::unique_ptr<base::DictionaryValue> description(
       cloud_print::PrinterSemanticCapsAndDefaultsToCdd(info));
   if (!description) {
     LOG(WARNING) << "Failed to convert capabilities for " << printer_name;
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
   }
 
   return description;
 }
 
 void EnumeratePrintersOnFileThread(base::ListValue* printers) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   scoped_refptr<printing::PrintBackend> print_backend(
       printing::PrintBackend::CreateInstance(NULL));
@@ skipping 46 matching lines @@
     GetPrinterCapabilitiesFailureCallback;
 
 void GetPrinterCapabilitiesOnFileThread(
     const std::string& printer_name,
     const std::string& locale,
     const GetPrinterCapabilitiesSuccessCallback& success_cb,
     const GetPrinterCapabilitiesFailureCallback& failure_cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!printer_name.empty());
 
-  scoped_ptr<base::DictionaryValue> printer_capabilities(
-      printer_name == kLocalPdfPrinterId ?
-      GetPdfCapabilitiesOnFileThread(locale) :
-      GetLocalPrinterCapabilitiesOnFileThread(printer_name));
+  std::unique_ptr<base::DictionaryValue> printer_capabilities(
+      printer_name == kLocalPdfPrinterId
+          ? GetPdfCapabilitiesOnFileThread(locale)
+          : GetLocalPrinterCapabilitiesOnFileThread(printer_name));
   if (!printer_capabilities) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(failure_cb, printer_name));
     return;
   }
 
-  scoped_ptr<base::DictionaryValue> printer_info(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> printer_info(
+      new base::DictionaryValue);
   printer_info->SetString(kPrinterId, printer_name);
   printer_info->Set(kPrinterCapabilities, printer_capabilities.release());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(success_cb, base::Owned(printer_info.release())));
 }
 
 base::LazyInstance<printing::StickySettings> g_sticky_settings =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 45 matching lines @@
       chromeos::DeviceOAuth2TokenService* token_service =
           chromeos::DeviceOAuth2TokenServiceFactory::Get();
       account_id = token_service->GetRobotAccountId();
       service = token_service;
 #endif
     }
 
     if (service) {
       OAuth2TokenService::ScopeSet oauth_scopes;
       oauth_scopes.insert(cloud_devices::kCloudPrintAuthScope);
-      scoped_ptr<OAuth2TokenService::Request> request(
+      std::unique_ptr<OAuth2TokenService::Request> request(
           service->StartRequest(account_id, oauth_scopes, this));
       requests_[type].reset(request.release());
     } else {
       handler_->SendAccessToken(type, std::string());  // Unknown type.
     }
   }
 
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override {
@@ skipping 12 matching lines @@
       if (i->second.get() == request) {
         handler_->SendAccessToken(i->first, access_token);
         requests_.erase(i);
         return;
       }
     }
     NOTREACHED();
   }
 
   using Requests =
-      std::map<std::string, scoped_ptr<OAuth2TokenService::Request>>;
+      std::map<std::string, std::unique_ptr<OAuth2TokenService::Request>>;
   Requests requests_;
   PrintPreviewHandler* handler_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
 };
 
 PrintPreviewHandler::PrintPreviewHandler()
     : regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       manage_cloud_printers_dialog_request_count_(0),
@@ skipping 174 matching lines @@
 
   EnsureExtensionPrinterHandlerSet();
   extension_printer_handler_->StartGetCapability(
       printer_id,
       base::Bind(&PrintPreviewHandler::OnGotExtensionPrinterCapabilities,
                  base::Unretained(this)));
 }
 
 void PrintPreviewHandler::HandleGetPreview(const base::ListValue* args) {
   DCHECK_EQ(3U, args->GetSize());
-  scoped_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
+  std::unique_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
   if (!settings)
     return;
   int request_id = -1;
   if (!settings->GetInteger(printing::kPreviewRequestID, &request_id))
     return;
 
   print_preview_ui()->OnPrintPreviewRequest(request_id);
   // Add an additional key in order to identify |print_preview_ui| later on
   // when calling PrintPreviewUI::GetCurrentPrintPreviewStatus() on the IO
   // thread.
@@ skipping 75 matching lines @@
 }
 
 void PrintPreviewHandler::HandlePrint(const base::ListValue* args) {
   ReportStats();
 
   // Record the number of times the user requests to regenerate preview data
   // before printing.
   UMA_HISTOGRAM_COUNTS("PrintPreview.RegeneratePreviewRequest.BeforePrint",
                        regenerate_preview_request_count_);
 
-  scoped_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
+  std::unique_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
   if (!settings)
     return;
 
   ReportPrintSettingsStats(*settings);
 
   // Never try to add headers/footers here. It's already in the generated PDF.
   settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
 
   bool print_to_pdf = false;
   bool is_cloud_printer = false;
@@ skipping 649 matching lines @@
   }
 }
 
 void PrintPreviewHandler::LocalPrinterRemoved(const std::string& name) {
 }
 
 void PrintPreviewHandler::LocalPrinterCacheFlushed() {
 }
 
 void PrintPreviewHandler::PrivetCapabilitiesUpdateClient(
-    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
+    std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!PrivetUpdateClient(std::move(http_client)))
     return;
 
   privet_capabilities_operation_ =
       privet_http_client_->CreateCapabilitiesOperation(
           base::Bind(&PrintPreviewHandler::OnPrivetCapabilities,
                      base::Unretained(this)));
   privet_capabilities_operation_->Start();
 }
 
 bool PrintPreviewHandler::PrivetUpdateClient(
-    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
+    std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!http_client) {
     SendPrivetCapabilitiesError(privet_http_resolution_->GetName());
     privet_http_resolution_.reset();
     return false;
   }
 
   privet_local_print_operation_.reset();
   privet_capabilities_operation_.reset();
   privet_http_client_ = cloud_print::PrivetV1HTTPClient::CreateDefault(
       std::move(http_client));
 
   privet_http_resolution_.reset();
 
   return true;
 }
 
 void PrintPreviewHandler::PrivetLocalPrintUpdateClient(
     std::string print_ticket,
     std::string capabilities,
     gfx::Size page_size,
-    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
+    std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!PrivetUpdateClient(std::move(http_client)))
     return;
 
   StartPrivetLocalPrint(print_ticket, capabilities, page_size);
 }
 
 void PrintPreviewHandler::StartPrivetLocalPrint(const std::string& print_ticket,
                                                 const std::string& capabilities,
                                                 const gfx::Size& page_size) {
   privet_local_print_operation_ =
@@ skipping 198 matching lines @@
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }