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

chrome/browser/chromeos/fileapi/external_file_url_request_job_unittest.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/chromeos/fileapi/external_file_url_request_job.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
@@ skipping 126 matching lines @@
     url_request_context_.reset(new net::URLRequestContext());
     url_request_context_->set_job_factory(test_url_request_job_factory_.get());
     url_request_context_->set_network_delegate(test_network_delegate_.get());
     test_delegate_.reset(new TestDelegate);
   }
 
   void TearDown() override { profile_manager_.reset(); }
 
   bool ReadDriveFileSync(const base::FilePath& file_path,
                          std::string* out_content) {
-    scoped_ptr<base::Thread> worker_thread(
+    std::unique_ptr<base::Thread> worker_thread(
         new base::Thread("ReadDriveFileSync"));
     if (!worker_thread->Start())
       return false;
 
-    scoped_ptr<drive::DriveFileStreamReader> reader(
+    std::unique_ptr<drive::DriveFileStreamReader> reader(
         new drive::DriveFileStreamReader(
             base::Bind(&ExternalFileURLRequestJobTest::GetFileSystem,
                        base::Unretained(this)),
             worker_thread->task_runner().get()));
     int error = net::ERR_FAILED;
-    scoped_ptr<drive::ResourceEntry> entry;
+    std::unique_ptr<drive::ResourceEntry> entry;
     {
       base::RunLoop run_loop;
       reader->Initialize(file_path,
                          net::HttpByteRange(),
                          google_apis::test_util::CreateQuitCallback(
                              &run_loop,
                              google_apis::test_util::CreateCopyResultCallback(
                                  &error, &entry)));
       run_loop.Run();
     }
     if (error != net::OK || !entry)
       return false;
 
     // Read data from the reader.
     std::string content;
     if (drive::test_util::ReadAllData(reader.get(), &content) != net::OK)
       return false;
 
     if (static_cast<size_t>(entry->file_info().size()) != content.size())
       return false;
 
     *out_content = content;
     return true;
   }
 
-  scoped_ptr<net::URLRequestContext> url_request_context_;
-  scoped_ptr<TestDelegate> test_delegate_;
+  std::unique_ptr<net::URLRequestContext> url_request_context_;
+  std::unique_ptr<TestDelegate> test_delegate_;
 
  private:
   // Create the drive integration service for the |profile|
   drive::DriveIntegrationService* CreateDriveIntegrationService(
       Profile* profile) {
     drive::FakeDriveService* const drive_service = new drive::FakeDriveService;
     if (!drive::test_util::SetUpTestEntries(drive_service))
       return NULL;
 
     const std::string& drive_mount_name =
@@ skipping 13 matching lines @@
                                               drive_mount_name,
                                               drive_cache_dir_.path(),
                                               fake_file_system_);
   }
 
   drive::FileSystemInterface* GetFileSystem() { return fake_file_system_; }
 
   content::TestBrowserThreadBundle thread_bundle_;
   drive::DriveIntegrationServiceFactory::FactoryCallback
       integration_service_factory_callback_;
-  scoped_ptr<drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>
+  std::unique_ptr<drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>
       integration_service_factory_scope_;
-  scoped_ptr<drive::DriveIntegrationService> integration_service_;
+  std::unique_ptr<drive::DriveIntegrationService> integration_service_;
   drive::test_util::FakeFileSystem* fake_file_system_;
 
-  scoped_ptr<net::TestNetworkDelegate> test_network_delegate_;
-  scoped_ptr<TestURLRequestJobFactory> test_url_request_job_factory_;
+  std::unique_ptr<net::TestNetworkDelegate> test_network_delegate_;
+  std::unique_ptr<TestURLRequestJobFactory> test_url_request_job_factory_;
 
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
   base::ScopedTempDir drive_cache_dir_;
   scoped_refptr<storage::FileSystemContext> file_system_context_;
 };
 
 TEST_F(ExternalFileURLRequestJobTest, NonGetMethod) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->set_method("POST");  // Set non "GET" method.
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_METHOD_NOT_SUPPORTED, request->status().error());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RegularFile) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
   const base::FilePath kTestFilePath("drive/root/File 1.txt");
 
   // For the first time, the file should be fetched from the server.
   {
-    scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
-        kTestUrl, net::DEFAULT_PRIORITY, test_delegate_.get()));
+    std::unique_ptr<net::URLRequest> request(
+        url_request_context_->CreateRequest(kTestUrl, net::DEFAULT_PRIORITY,
+                                            test_delegate_.get()));
     request->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
     // It looks weird, but the mime type for the "File 1.txt" is "audio/mpeg"
     // on the server.
     std::string mime_type;
     request->GetMimeType(&mime_type);
     EXPECT_EQ("audio/mpeg", mime_type);
 
     // Reading file must be done after |request| runs, otherwise
     // it'll create a local cache file, and we cannot test correctly.
     std::string expected_data;
     ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
     EXPECT_EQ(expected_data, test_delegate_->data_received());
   }
 
   // For the second time, the locally cached file should be used.
   // The caching emulation is done by FakeFileSystem.
   {
     test_delegate_.reset(new TestDelegate);
-    scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
-        GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
-        net::DEFAULT_PRIORITY, test_delegate_.get()));
+    std::unique_ptr<net::URLRequest> request(
+        url_request_context_->CreateRequest(
+            GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
+            net::DEFAULT_PRIORITY, test_delegate_.get()));
     request->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
     std::string mime_type;
     request->GetMimeType(&mime_type);
     EXPECT_EQ("audio/mpeg", mime_type);
 
     std::string expected_data;
     ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
     EXPECT_EQ(expected_data, test_delegate_->data_received());
   }
 }
 
 TEST_F(ExternalFileURLRequestJobTest, HostedDocument) {
   // Open a gdoc file.
   test_delegate_->set_quit_on_redirect(true);
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
-      GURL(
-          "externalfile:drive-test-user-hash/root/Document 1 "
-          "excludeDir-test.gdoc"),
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("externalfile:drive-test-user-hash/root/Document 1 "
+           "excludeDir-test.gdoc"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
   // Make sure that a hosted document triggers redirection.
   EXPECT_TRUE(request->is_redirecting());
   EXPECT_TRUE(test_delegate_->redirect_url().is_valid());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RootDirectory) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root"), net::DEFAULT_PRIORITY,
       test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_FAILED, request->status().error());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, Directory) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/Directory 1"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_FAILED, request->status().error());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, NonExistingFile) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/non-existing-file.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, WrongFormat) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:"), net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_INVALID_URL, request->status().error());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, Cancel) {
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Start the request, and cancel it immediately after it.
   request->Start();
   request->Cancel();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, request->status().status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RangeHeader) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
   const base::FilePath kTestFilePath("drive/root/File 1.txt");
 
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       kTestUrl, net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Set range header.
   request->SetExtraRequestHeaderByName(
       "Range", "bytes=3-5", false /* overwrite */);
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
 
   // Reading file must be done after |request| runs, otherwise
   // it'll create a local cache file, and we cannot test correctly.
   std::string expected_data;
   ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
   EXPECT_EQ(expected_data.substr(3, 3), test_delegate_->data_received());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, WrongRangeHeader) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
 
-  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       kTestUrl, net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Set range header.
   request->SetExtraRequestHeaderByName(
       "Range", "Wrong Range Header Value", false /* overwrite */);
   request->Start();
 
   base::RunLoop().Run();
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, request->status().error());
 }
 
 }  // namespace chromeos