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

chrome/browser/chromeos/printer_detector/printer_detector_unittest.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/chromeos/printer_detector/printer_detector.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/printer_detector/printer_detector_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
@@ skipping 40 matching lines @@
   }
 
   void set_usb_service(device::UsbService* service) { usb_service_ = service; }
 
  private:
   device::UsbService* usb_service_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDeviceClient);
 };
 
-scoped_ptr<KeyedService> CreatePrinterDetector(
+std::unique_ptr<KeyedService> CreatePrinterDetector(
     content::BrowserContext* context) {
-  return scoped_ptr<KeyedService>(
+  return std::unique_ptr<KeyedService>(
       new chromeos::PrinterDetector(Profile::FromBrowserContext(context)));
 }
 
 }  // namespace
 
 // TODO(tbarzic): Rename this test.
 class PrinterDetectorAppSearchEnabledTest : public testing::Test {
  public:
   PrinterDetectorAppSearchEnabledTest()
       : user_manager_(new user_manager::FakeUserManager()),
@@ skipping 36 matching lines @@
                       uint16_t product_id,
                       uint8_t interface_class) {
     device::UsbConfigDescriptor config(1, false, false, 0);
     config.interfaces.emplace_back(1, 0, interface_class, 0, 0);
     usb_service_.AddDevice(
         new device::MockUsbDevice(vendor_id, product_id, config));
   }
 
   // Creates a test extension with the provided permissions.
   scoped_refptr<extensions::Extension> CreateTestExtension(
-      scoped_ptr<base::ListValue> permissions_builder,
-      scoped_ptr<base::DictionaryValue> usb_printers_builder) {
+      std::unique_ptr<base::ListValue> permissions_builder,
+      std::unique_ptr<base::DictionaryValue> usb_printers_builder) {
     return extensions::ExtensionBuilder()
         .SetID("fake_extension_id")
         .SetManifest(
             DictionaryBuilder()
                 .Set("name", "Printer provider extension")
                 .Set("manifest_version", 2)
                 .Set("version", "1.0")
                 // Needed to enable usb API.
                 .Set("app",
                      DictionaryBuilder()
                          .Set("background",
                               DictionaryBuilder()
                                   .Set("scripts",
                                        ListBuilder().Append("bg.js").Build())
                                   .Build())
                          .Build())
                 .Set("permissions", std::move(permissions_builder))
                 .Set("usb_printers", std::move(usb_printers_builder))
                 .Build())
         .Build();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   StubNotificationUIManager notification_ui_manager_;
   user_manager::FakeUserManager* user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   device::MockUsbService usb_service_;
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<TestingProfile> profile_;
   FakeDeviceClient device_client_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterDetectorAppSearchEnabledTest);
 };
 
 TEST_F(PrinterDetectorAppSearchEnabledTest, ShowFindAppNotification) {
   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 
   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
   const Notification& notification =
@@ skipping 185 matching lines @@
           .Build());
   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
                   ->AddEnabled(extension));
 
   InvokeUsbAdded(123, 456, 1);
 
   ASSERT_EQ(0u, notification_ui_manager_.GetNotificationCount());
 }
 
 }  // namespace chromeos