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

chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc

 // Copyright 2015 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/extension_printer_handler.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/browser/printing/pwg_raster_converter.h"
-#include "chrome/browser/ui/webui/print_preview/extension_printer_handler.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/version_info/version_info.h"
 #include "device/core/device_client.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
 #include "extensions/common/extension.h"
@@ skipping 145 matching lines @@
 
 const char kContentTypePDF[] = "application/pdf";
 const char kContentTypePWG[] = "image/pwg-raster";
 
 // Print request status considered to be successful by fake PrinterProviderAPI.
 const char kPrintRequestSuccess[] = "OK";
 
 // Used as a callback to StartGetPrinters in tests.
 // Increases |*call_count| and records values returned by StartGetPrinters.
 void RecordPrinterList(size_t* call_count,
-                       scoped_ptr<base::ListValue>* printers_out,
+                       std::unique_ptr<base::ListValue>* printers_out,
                        bool* is_done_out,
                        const base::ListValue& printers,
                        bool is_done) {
   ++(*call_count);
   printers_out->reset(printers.DeepCopy());
   *is_done_out = is_done;
 }
 
 // Used as a callback to StartGetCapability in tests.
 // Increases |*call_count| and records values returned by StartGetCapability.
 void RecordCapability(size_t* call_count,
                       std::string* destination_id_out,
-                      scoped_ptr<base::DictionaryValue>* capability_out,
+                      std::unique_ptr<base::DictionaryValue>* capability_out,
                       const std::string& destination_id,
                       const base::DictionaryValue& capability) {
   ++(*call_count);
   *destination_id_out = destination_id;
   capability_out->reset(capability.DeepCopy());
 }
 
 // Used as a callback to StartPrint in tests.
 // Increases |*call_count| and records values returned by StartPrint.
 void RecordPrintResult(size_t* call_count,
                        bool* success_out,
                        std::string* status_out,
                        bool success,
                        const std::string& status) {
   ++(*call_count);
   *success_out = success;
   *status_out = status;
 }
 
 // Used as a callback to StartGrantPrinterAccess in tests.
 // Increases |*call_count| and records the value returned.
 void RecordPrinterInfo(size_t* call_count,
-                       scoped_ptr<base::DictionaryValue>* printer_info_out,
+                       std::unique_ptr<base::DictionaryValue>* printer_info_out,
                        const base::DictionaryValue& printer_info) {
   ++(*call_count);
   printer_info_out->reset(printer_info.DeepCopy());
 }
 
 // Converts JSON string to base::ListValue object.
 // On failure, returns NULL and fills |*error| string.
-scoped_ptr<base::ListValue> GetJSONAsListValue(const std::string& json,
-                                               std::string* error) {
-  scoped_ptr<base::Value> deserialized(
+std::unique_ptr<base::ListValue> GetJSONAsListValue(const std::string& json,
+                                                    std::string* error) {
+  std::unique_ptr<base::Value> deserialized(
       JSONStringValueDeserializer(json).Deserialize(NULL, error));
   if (!deserialized)
-    return scoped_ptr<base::ListValue>();
+    return std::unique_ptr<base::ListValue>();
   base::ListValue* list = nullptr;
   if (!deserialized->GetAsList(&list)) {
     *error = "Value is not a list.";
-    return scoped_ptr<base::ListValue>();
+    return std::unique_ptr<base::ListValue>();
   }
-  return scoped_ptr<base::ListValue>(list->DeepCopy());
+  return std::unique_ptr<base::ListValue>(list->DeepCopy());
 }
 
 // Converts JSON string to base::DictionaryValue object.
 // On failure, returns NULL and fills |*error| string.
-scoped_ptr<base::DictionaryValue> GetJSONAsDictionaryValue(
+std::unique_ptr<base::DictionaryValue> GetJSONAsDictionaryValue(
     const std::string& json,
     std::string* error) {
-  scoped_ptr<base::Value> deserialized(
+  std::unique_ptr<base::Value> deserialized(
       JSONStringValueDeserializer(json).Deserialize(NULL, error));
   if (!deserialized)
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
   base::DictionaryValue* dictionary;
   if (!deserialized->GetAsDictionary(&dictionary)) {
     *error = "Value is not a dictionary.";
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
   }
-  return scoped_ptr<base::DictionaryValue>(dictionary->DeepCopy());
+  return std::unique_ptr<base::DictionaryValue>(dictionary->DeepCopy());
 }
 
 std::string RefCountedMemoryToString(
     const scoped_refptr<base::RefCountedMemory>& memory) {
   return std::string(memory->front_as<char>(), memory->size());
 }
 
 // Fake PWGRasterConverter used in the tests.
 class FakePWGRasterConverter : public PWGRasterConverter {
  public:
@@ skipping 163 matching lines @@
       pending_printers_callbacks_;
   std::queue<PrinterProviderAPI::GetCapabilityCallback>
       pending_capability_callbacks_;
   std::queue<PrintRequestInfo> pending_print_requests_;
   std::queue<PrinterProviderAPI::GetPrinterInfoCallback>
       pending_usb_info_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FakePrinterProviderAPI);
 };
 
-scoped_ptr<KeyedService> BuildTestingPrinterProviderAPI(
+std::unique_ptr<KeyedService> BuildTestingPrinterProviderAPI(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new FakePrinterProviderAPI());
+  return base::WrapUnique(new FakePrinterProviderAPI());
 }
 
 class FakeDeviceClient : public device::DeviceClient {
  public:
   FakeDeviceClient() {}
 
   // device::DeviceClient implementation:
   device::UsbService* GetUsbService() override {
     DCHECK(usb_service_);
     return usb_service_;
@@ skipping 13 matching lines @@
   ~ExtensionPrinterHandlerTest() override = default;
 
   void SetUp() override {
     extensions::PrinterProviderAPIFactory::GetInstance()->SetTestingFactory(
         env_.profile(), &BuildTestingPrinterProviderAPI);
     extension_printer_handler_.reset(new ExtensionPrinterHandler(
         env_.profile(), base::MessageLoop::current()->task_runner()));
 
     pwg_raster_converter_ = new FakePWGRasterConverter();
     extension_printer_handler_->SetPWGRasterConverterForTesting(
-        scoped_ptr<PWGRasterConverter>(pwg_raster_converter_));
+        std::unique_ptr<PWGRasterConverter>(pwg_raster_converter_));
     device_client_.set_usb_service(&usb_service_);
   }
 
  protected:
   FakePrinterProviderAPI* GetPrinterProviderAPI() {
     return static_cast<FakePrinterProviderAPI*>(
         extensions::PrinterProviderAPIFactory::GetInstance()
             ->GetForBrowserContext(env_.profile()));
   }
 
   MockUsbService usb_service_;
   TestExtensionEnvironment env_;
-  scoped_ptr<ExtensionPrinterHandler> extension_printer_handler_;
+  std::unique_ptr<ExtensionPrinterHandler> extension_printer_handler_;
 
   FakePWGRasterConverter* pwg_raster_converter_;
 
  private:
   FakeDeviceClient device_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrinterHandlerTest);
 };
 
 TEST_F(ExtensionPrinterHandlerTest, GetPrinters) {
   size_t call_count = 0;
-  scoped_ptr<base::ListValue> printers;
+  std::unique_ptr<base::ListValue> printers;
   bool is_done = false;
 
   extension_printer_handler_->StartGetPrinters(
       base::Bind(&RecordPrinterList, &call_count, &printers, &is_done));
 
   EXPECT_FALSE(printers.get());
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_get_printers_count());
 
   std::string error;
-  scoped_ptr<base::ListValue> original_printers(
+  std::unique_ptr<base::ListValue> original_printers(
       GetJSONAsListValue(kPrinterDescriptionList, &error));
   ASSERT_TRUE(original_printers) << "Failed to deserialize printers: " << error;
 
   fake_api->TriggerNextGetPrintersCallback(*original_printers, true);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_TRUE(is_done);
   ASSERT_TRUE(printers.get());
   EXPECT_TRUE(printers->Equals(original_printers.get()))
       << *printers << ", expected: " << *original_printers;
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GetPrinters_Reset) {
   size_t call_count = 0;
-  scoped_ptr<base::ListValue> printers;
+  std::unique_ptr<base::ListValue> printers;
   bool is_done = false;
 
   extension_printer_handler_->StartGetPrinters(
       base::Bind(&RecordPrinterList, &call_count, &printers, &is_done));
 
   EXPECT_FALSE(printers.get());
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_get_printers_count());
 
   extension_printer_handler_->Reset();
 
   std::string error;
-  scoped_ptr<base::ListValue> original_printers(
+  std::unique_ptr<base::ListValue> original_printers(
       GetJSONAsListValue(kPrinterDescriptionList, &error));
   ASSERT_TRUE(original_printers) << "Error deserializing printers: " << error;
 
   fake_api->TriggerNextGetPrintersCallback(*original_printers, true);
 
   EXPECT_EQ(0u, call_count);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GetUsbPrinters) {
   scoped_refptr<MockUsbDevice> device0 =
       new MockUsbDevice(0, 0, "Google", "USB Printer", "");
   usb_service_.AddDevice(device0);
   scoped_refptr<MockUsbDevice> device1 =
       new MockUsbDevice(0, 1, "Google", "USB Printer", "");
   usb_service_.AddDevice(device1);
 
   const Extension* extension_1 = env_.MakeExtension(
       *base::test::ParseJson(kExtension1), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
   const Extension* extension_2 = env_.MakeExtension(
       *base::test::ParseJson(kExtension2), "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
 
   extensions::DevicePermissionsManager* permissions_manager =
       extensions::DevicePermissionsManager::Get(env_.profile());
   permissions_manager->AllowUsbDevice(extension_2->id(), device0);
 
   size_t call_count = 0;
-  scoped_ptr<base::ListValue> printers;
+  std::unique_ptr<base::ListValue> printers;
   bool is_done = false;
   extension_printer_handler_->StartGetPrinters(
       base::Bind(&RecordPrinterList, &call_count, &printers, &is_done));
 
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_get_printers_count());
 
   EXPECT_EQ(1u, call_count);
   EXPECT_FALSE(is_done);
   EXPECT_TRUE(printers.get());
   EXPECT_EQ(2u, printers->GetSize());
-  scoped_ptr<base::DictionaryValue> extension_1_entry(
+  std::unique_ptr<base::DictionaryValue> extension_1_entry(
       DictionaryBuilder()
           .Set("id", base::StringPrintf("provisional-usb:%s:%s",
                                         extension_1->id().c_str(),
                                         device0->guid().c_str()))
           .Set("name", "USB Printer")
           .Set("extensionName", "Provider 1")
           .Set("extensionId", extension_1->id())
           .Set("provisional", true)
           .Build());
-  scoped_ptr<base::DictionaryValue> extension_2_entry(
+  std::unique_ptr<base::DictionaryValue> extension_2_entry(
       DictionaryBuilder()
           .Set("id", base::StringPrintf("provisional-usb:%s:%s",
                                         extension_2->id().c_str(),
                                         device1->guid().c_str()))
           .Set("name", "USB Printer")
           .Set("extensionName", "Provider 2")
           .Set("extensionId", extension_2->id())
           .Set("provisional", true)
           .Build());
   EXPECT_TRUE(printers->Find(*extension_1_entry) != printers->end());
   EXPECT_TRUE(printers->Find(*extension_2_entry) != printers->end());
 
   fake_api->TriggerNextGetPrintersCallback(base::ListValue(), true);
 
   EXPECT_EQ(2u, call_count);
   EXPECT_TRUE(is_done);
   EXPECT_TRUE(printers.get());
   EXPECT_EQ(0u, printers->GetSize());  // RecordPrinterList resets |printers|.
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GetCapability) {
   size_t call_count = 0;
   std::string destination_id;
-  scoped_ptr<base::DictionaryValue> capability;
+  std::unique_ptr<base::DictionaryValue> capability;
 
   extension_printer_handler_->StartGetCapability(
       kPrinterId,
       base::Bind(&RecordCapability, &call_count, &destination_id, &capability));
 
   EXPECT_EQ(0u, call_count);
 
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_get_capability_count());
 
   std::string error;
-  scoped_ptr<base::DictionaryValue> original_capability(
+  std::unique_ptr<base::DictionaryValue> original_capability(
       GetJSONAsDictionaryValue(kPWGRasterOnlyPrinterSimpleDescription, &error));
   ASSERT_TRUE(original_capability)
       << "Error deserializing capability: " << error;
 
   fake_api->TriggerNextGetCapabilityCallback(*original_capability);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_EQ(kPrinterId, destination_id);
   ASSERT_TRUE(capability.get());
   EXPECT_TRUE(capability->Equals(original_capability.get()))
       << *capability << ", expected: " << *original_capability;
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GetCapability_Reset) {
   size_t call_count = 0;
   std::string destination_id;
-  scoped_ptr<base::DictionaryValue> capability;
+  std::unique_ptr<base::DictionaryValue> capability;
 
   extension_printer_handler_->StartGetCapability(
       kPrinterId,
       base::Bind(&RecordCapability, &call_count, &destination_id, &capability));
 
   EXPECT_EQ(0u, call_count);
 
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_get_capability_count());
 
   extension_printer_handler_->Reset();
 
   std::string error;
-  scoped_ptr<base::DictionaryValue> original_capability(
+  std::unique_ptr<base::DictionaryValue> original_capability(
       GetJSONAsDictionaryValue(kPWGRasterOnlyPrinterSimpleDescription, &error));
   ASSERT_TRUE(original_capability)
       << "Error deserializing capability: " << error;
 
   fake_api->TriggerNextGetCapabilityCallback(*original_capability);
 
   EXPECT_EQ(0u, call_count);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, Print_Pdf) {
@@ skipping 283 matching lines @@
   EXPECT_FALSE(success);
   EXPECT_EQ("INVALID_DATA", status);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess) {
   scoped_refptr<MockUsbDevice> device =
       new MockUsbDevice(0, 0, "Google", "USB Printer", "");
   usb_service_.AddDevice(device);
 
   size_t call_count = 0;
-  scoped_ptr<base::DictionaryValue> printer_info;
+  std::unique_ptr<base::DictionaryValue> printer_info;
 
   std::string printer_id = base::StringPrintf(
       "provisional-usb:fake extension id:%s", device->guid().c_str());
   extension_printer_handler_->StartGrantPrinterAccess(
       printer_id, base::Bind(&RecordPrinterInfo, &call_count, &printer_info));
 
   EXPECT_FALSE(printer_info.get());
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_usb_info_count());
 
-  scoped_ptr<base::DictionaryValue> original_printer_info(
+  std::unique_ptr<base::DictionaryValue> original_printer_info(
       DictionaryBuilder()
           .Set("id", "printer1")
           .Set("name", "Printer 1")
           .Build());
 
   fake_api->TriggerNextUsbPrinterInfoCallback(*original_printer_info);
 
   EXPECT_EQ(1u, call_count);
   ASSERT_TRUE(printer_info.get());
   EXPECT_TRUE(printer_info->Equals(original_printer_info.get()))
       << *printer_info << ", expected: " << *original_printer_info;
 }
 
 TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess_Reset) {
   scoped_refptr<MockUsbDevice> device =
       new MockUsbDevice(0, 0, "Google", "USB Printer", "");
   usb_service_.AddDevice(device);
 
   size_t call_count = 0;
-  scoped_ptr<base::DictionaryValue> printer_info;
+  std::unique_ptr<base::DictionaryValue> printer_info;
 
   extension_printer_handler_->StartGrantPrinterAccess(
       base::StringPrintf("provisional-usb:fake extension id:%s",
                          device->guid().c_str()),
       base::Bind(&RecordPrinterInfo, &call_count, &printer_info));
 
   EXPECT_FALSE(printer_info.get());
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_usb_info_count());
 
   extension_printer_handler_->Reset();
 
-  scoped_ptr<base::DictionaryValue> original_printer_info(
+  std::unique_ptr<base::DictionaryValue> original_printer_info(
       DictionaryBuilder()
           .Set("id", "printer1")
           .Set("name", "Printer 1")
           .Build());
 
   fake_api->TriggerNextUsbPrinterInfoCallback(*original_printer_info);
 
   EXPECT_EQ(0u, call_count);
   EXPECT_FALSE(printer_info.get());
 }