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

chrome/browser/chromeos/file_system_provider/provided_file_system_unittest.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 "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_observer.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
@@ skipping 29 matching lines @@
 class FakeEventRouter : public extensions::EventRouter {
  public:
   FakeEventRouter(Profile* profile, ProvidedFileSystemInterface* file_system)
       : EventRouter(profile, NULL),
         file_system_(file_system),
         reply_result_(base::File::FILE_OK) {}
   ~FakeEventRouter() override {}
 
   // Handles an event which would normally be routed to an extension. Instead
   // replies with a hard coded response.
-  void DispatchEventToExtension(const std::string& extension_id,
-                                scoped_ptr<extensions::Event> event) override {
+  void DispatchEventToExtension(
+      const std::string& extension_id,
+      std::unique_ptr<extensions::Event> event) override {
     ASSERT_TRUE(file_system_);
     std::string file_system_id;
     const base::DictionaryValue* dictionary_value = NULL;
     ASSERT_TRUE(event->event_args->GetDictionary(0, &dictionary_value));
     EXPECT_TRUE(dictionary_value->GetString("fileSystemId", &file_system_id));
     EXPECT_EQ(kFileSystemId, file_system_id);
     int request_id = -1;
     EXPECT_TRUE(dictionary_value->GetInteger("requestId", &request_id));
     EXPECT_TRUE(event->event_name == extensions::api::file_system_provider::
                                          OnAddWatcherRequested::kEventName ||
                 event->event_name == extensions::api::file_system_provider::
                                          OnRemoveWatcherRequested::kEventName ||
                 event->event_name == extensions::api::file_system_provider::
                                          OnOpenFileRequested::kEventName ||
                 event->event_name == extensions::api::file_system_provider::
                                          OnCloseFileRequested::kEventName);
 
     if (reply_result_ == base::File::FILE_OK) {
       base::ListValue value_as_list;
       value_as_list.Set(0, new base::StringValue(kFileSystemId));
       value_as_list.Set(1, new base::FundamentalValue(request_id));
       value_as_list.Set(2, new base::FundamentalValue(0) /* execution_time */);
 
       using extensions::api::file_system_provider_internal::
           OperationRequestedSuccess::Params;
-      scoped_ptr<Params> params(Params::Create(value_as_list));
+      std::unique_ptr<Params> params(Params::Create(value_as_list));
       ASSERT_TRUE(params.get());
       file_system_->GetRequestManager()->FulfillRequest(
           request_id,
           RequestValue::CreateForOperationSuccess(std::move(params)),
           false /* has_more */);
     } else {
       file_system_->GetRequestManager()->RejectRequest(
-          request_id, make_scoped_ptr(new RequestValue()), reply_result_);
+          request_id, base::WrapUnique(new RequestValue()), reply_result_);
     }
   }
 
   void set_reply_result(base::File::Error result) { reply_result_ = result; }
 
  private:
   ProvidedFileSystemInterface* const file_system_;  // Not owned.
   base::File::Error reply_result_;
   DISALLOW_COPY_AND_ASSIGN(FakeEventRouter);
 };
@@ skipping 140 matching lines @@
                                     NULL,
                                     kExtensionId);
     event_router_->AddEventListener(
         extensions::api::file_system_provider::OnOpenFileRequested::kEventName,
         NULL, kExtensionId);
     event_router_->AddEventListener(
         extensions::api::file_system_provider::OnCloseFileRequested::kEventName,
         NULL, kExtensionId);
     provided_file_system_->SetEventRouterForTesting(event_router_.get());
     provided_file_system_->SetNotificationManagerForTesting(
-        make_scoped_ptr(new StubNotificationManager));
+        base::WrapUnique(new StubNotificationManager));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<FakeEventRouter> event_router_;
-  scoped_ptr<ProvidedFileSystemInfo> file_system_info_;
-  scoped_ptr<ProvidedFileSystem> provided_file_system_;
+  std::unique_ptr<TestingProfile> profile_;
+  std::unique_ptr<FakeEventRouter> event_router_;
+  std::unique_ptr<ProvidedFileSystemInfo> file_system_info_;
+  std::unique_ptr<ProvidedFileSystem> provided_file_system_;
 };
 
 TEST_F(FileSystemProviderProvidedFileSystemTest, AutoUpdater) {
   Log log;
   base::Closure firstCallback;
   base::Closure secondCallback;
 
   {
     // Auto updater is ref counted, and bound to all callbacks.
     scoped_refptr<AutoUpdater> auto_updater(new AutoUpdater(
@@ skipping 136 matching lines @@
     mount_options.file_system_id = kFileSystemId;
     mount_options.display_name = kDisplayName;
     mount_options.supports_notify_tag = false;
     ProvidedFileSystemInfo file_system_info(
         kExtensionId, mount_options, mount_path, false /* configurable */,
         true /* watchable */, extensions::SOURCE_FILE);
     ProvidedFileSystem simple_provided_file_system(profile_.get(),
                                                    file_system_info);
     simple_provided_file_system.SetEventRouterForTesting(event_router_.get());
     simple_provided_file_system.SetNotificationManagerForTesting(
-        make_scoped_ptr(new StubNotificationManager));
+        base::WrapUnique(new StubNotificationManager));
 
     simple_provided_file_system.AddObserver(&observer);
 
     simple_provided_file_system.AddWatcher(
         GURL(kOrigin), base::FilePath(kDirectoryPath), false /* recursive */,
         true /* persistent */, base::Bind(&LogStatus, base::Unretained(&log)),
         storage::WatcherManager::NotificationCallback());
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
@@ skipping 308 matching lines @@
 
   {
     // Notify about a change.
     const storage::WatcherManager::ChangeType change_type =
         storage::WatcherManager::CHANGED;
     const std::string tag = "hello-world";
 
     Log log;
     provided_file_system_->Notify(
         base::FilePath(kDirectoryPath), false /* recursive */, change_type,
-        make_scoped_ptr(new ProvidedFileSystemObserver::Changes), tag,
+        base::WrapUnique(new ProvidedFileSystemObserver::Changes), tag,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     // Confirm that the notification callback was called.
     ASSERT_EQ(1u, notification_log.size());
     EXPECT_EQ(change_type, notification_log[0]);
 
     // Verify the observer event.
     ASSERT_EQ(1u, observer.change_events().size());
     const Observer::ChangeEvent* const change_event =
@@ skipping 25 matching lines @@
   {
     // Notify about deleting of the watched entry.
     const storage::WatcherManager::ChangeType change_type =
         storage::WatcherManager::DELETED;
     const ProvidedFileSystemObserver::Changes changes;
     const std::string tag = "chocolate-disco";
 
     Log log;
     provided_file_system_->Notify(
         base::FilePath(kDirectoryPath), false /* recursive */, change_type,
-        make_scoped_ptr(new ProvidedFileSystemObserver::Changes), tag,
+        base::WrapUnique(new ProvidedFileSystemObserver::Changes), tag,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     // Complete all change events.
     observer.CompleteOnWatcherChanged();
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_OK, log[0]);
 
@@ skipping 104 matching lines @@
 
   ASSERT_EQ(1u, close_log.size());
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, close_log[0]);
   EXPECT_EQ(0u, opened_files.size());
 
   provided_file_system_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos