Use ExternalFileSystemBackend in the DriveURLRequestJob.

chrome/browser/chromeos/drive/drive_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/drive/drive_url_request_job.h"
 
 #include "base/bind.h"
+#include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
-#include "base/sequenced_task_runner.h"
-#include "base/threading/sequenced_worker_pool.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/fake_file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/drive/fake_drive_service.h"
 #include "chrome/browser/drive/test_util.h"
+#include "chrome/browser/prefs/browser_prefs.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "components/pref_registry/testing_pref_service_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_file_system_options.h"
 #include "google_apis/drive/test_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_byte_range.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
+#include "storage/browser/fileapi/external_mount_points.h"
+#include "storage/browser/fileapi/file_system_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace drive {
 namespace {
+class MockProfileManager : public ProfileManagerWithoutInit {

[mtomasz, 2014/09/19 05:30:53]

Is this \n after namespace { and before closing consistent with other Chromium
files?

[hirono, 2014/09/19 06:26:36]

Done.

+ public:
+  explicit MockProfileManager(const base::FilePath& user_data_dir)

[mtomasz, 2014/09/19 05:30:53]

I think this is not a mock. It's rather some kind of TestingProfileManager or
FakeProfileManager.

Per:
http://stackoverflow.com/questions/346372/whats-the-difference-between-faking...

[hirono, 2014/09/19 06:26:36]

I removed the class as you suggested. Thank you!

+      : ProfileManagerWithoutInit(user_data_dir) {}
+
+ protected:
+  virtual Profile* CreateProfileHelper(

[mtomasz, 2014/09/19 05:30:53]

Why is this needed? Do we need method? If so, then why? Please add comments.

[hirono, 2014/09/19 06:26:36]

I removed the class as you suggested. Thank you!

+      const base::FilePath& file_path) OVERRIDE {
+    if (!base::PathExists(file_path)) {
+      if (!base::CreateDirectory(file_path))
+        return NULL;
+    }
+    return new TestingProfile(file_path);
+  }
+};

[mtomasz, 2014/09/19 05:30:53]

In general, is this entire class needed? Isn't TestingProfileManager enough?

[hirono, 2014/09/19 06:26:36]

I found the class is not needed. Removed.

 
 // A simple URLRequestJobFactory implementation to create DriveURLRequestJob.
 class TestURLRequestJobFactory : public net::URLRequestJobFactory {
  public:
-  TestURLRequestJobFactory(
-      const DriveURLRequestJob::FileSystemGetter& file_system_getter,
-      base::SequencedTaskRunner* sequenced_task_runner)
-      : file_system_getter_(file_system_getter),
-        sequenced_task_runner_(sequenced_task_runner) {
-  }
+  explicit TestURLRequestJobFactory(void* profile_id)
+      : profile_id_(profile_id) {}
 
   virtual ~TestURLRequestJobFactory() {}
 
   // net::URLRequestJobFactory override:
   virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return new DriveURLRequestJob(file_system_getter_,
-                                  sequenced_task_runner_.get(),
-                                  request,
-                                  network_delegate);
+    return new DriveURLRequestJob(profile_id_, request, network_delegate);
   }
 
   virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
     return scheme == chrome::kDriveScheme;
   }
 
   virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
     return url.is_valid() && IsHandledProtocol(url.scheme());
   }
 
   virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
     return true;
   }
 
  private:
-  const DriveURLRequestJob::FileSystemGetter file_system_getter_;
-  scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_;
-
+  void* const profile_id_;
   DISALLOW_COPY_AND_ASSIGN(TestURLRequestJobFactory);
 };
 
 class TestDelegate : public net::TestDelegate {
  public:
   TestDelegate() {}
 
   const GURL& redirect_url() const { return redirect_url_; }
 
   // net::TestDelegate override.
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const net::RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE{
+                                  bool* defer_redirect) OVERRIDE {
     redirect_url_ = redirect_info.new_url;
     net::TestDelegate::OnReceivedRedirect(
         request, redirect_info, defer_redirect);
   }
 
  private:
   GURL redirect_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 }  // namespace
 
 class DriveURLRequestJobTest : public testing::Test {
  protected:
   DriveURLRequestJobTest()
-      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
-  }
+      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+        integration_service_factory_callback_(
+            base::Bind(&DriveURLRequestJobTest::GetDriveIntegrationService,
+                       base::Unretained(this))),
+        fake_file_system_(NULL) {}
 
   virtual ~DriveURLRequestJobTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    // Initialize FakeDriveService.
-    fake_drive_service_.reset(new FakeDriveService);
-    ASSERT_TRUE(test_util::SetUpTestEntries(fake_drive_service_.get()));
+    // Create a testing profile.
+    prefs_.reset(new TestingPrefServiceSimple);
+    chrome::RegisterLocalState(prefs_->registry());
+    TestingBrowserProcess::GetGlobal()->SetLocalState(prefs_.get());
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    ProfileManager* const profile_manager =
+        new MockProfileManager(temp_dir_.path());
+    TestingBrowserProcess::GetGlobal()->SetProfileManager(profile_manager);
+    Profile* const profile =
+        profile_manager->GetProfile(temp_dir_.path().Append("user"));
 
-    // Initialize FakeFileSystem.
-    fake_file_system_.reset(
-        new test_util::FakeFileSystem(fake_drive_service_.get()));
+    // Create the drive integration service for the profile.
+    integration_service_factory_scope_.reset(
+        new DriveIntegrationServiceFactory::ScopedFactoryForTest(
+            &integration_service_factory_callback_));
+    DriveIntegrationServiceFactory::GetForProfile(profile);
 
-    scoped_refptr<base::SequencedWorkerPool> blocking_pool =
-        content::BrowserThread::GetBlockingPool();
+    // Create the URL request job factory.
     test_network_delegate_.reset(new net::TestNetworkDelegate);
-    test_url_request_job_factory_.reset(new TestURLRequestJobFactory(
-        base::Bind(&DriveURLRequestJobTest::GetFileSystem,
-                   base::Unretained(this)),
-        blocking_pool->GetSequencedTaskRunner(
-            blocking_pool->GetSequenceToken()).get()));
+    test_url_request_job_factory_.reset(new TestURLRequestJobFactory(profile));
     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);
   }
 
-  FileSystemInterface* GetFileSystem() {
-    return fake_file_system_.get();
+  virtual void TearDown() {
+    TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
+    TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
   }
 
   bool ReadDriveFileSync(
       const base::FilePath& file_path, std::string* out_content) {
     scoped_ptr<base::Thread> worker_thread(
         new base::Thread("ReadDriveFileSync"));
     if (!worker_thread->Start())
       return false;
 
     scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
@@ skipping 21 matching lines @@
     if (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_;
+
+ private:
+  // Create the drive integration service for the |profile|
+  DriveIntegrationService* GetDriveIntegrationService(Profile* profile) {
+    FakeDriveService* const drive_service = new FakeDriveService;
+    if (!test_util::SetUpTestEntries(drive_service))
+      return NULL;
+
+    const std::string& drive_mount_name =
+        util::GetDriveMountPointPath(profile).BaseName().AsUTF8Unsafe();
+    storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+        drive_mount_name,
+        storage::kFileSystemTypeDrive,
+        storage::FileSystemMountOption(),
+        util::GetDriveMountPointPath(profile));
+    DCHECK(!fake_file_system_);
+    fake_file_system_ = new test_util::FakeFileSystem(drive_service);
+    return new drive::DriveIntegrationService(profile,
+                                              NULL,
+                                              drive_service,
+                                              drive_mount_name,
+                                              temp_dir_.path().Append("cache"),
+                                              fake_file_system_);
+  }
+
+  FileSystemInterface* GetFileSystem() { return fake_file_system_; }
+
   content::TestBrowserThreadBundle thread_bundle_;
-
-  scoped_ptr<FakeDriveService> fake_drive_service_;
-  scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
+  DriveIntegrationServiceFactory::FactoryCallback
+      integration_service_factory_callback_;
+  scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
+      integration_service_factory_scope_;
+  scoped_ptr<DriveIntegrationService> integration_service_;
+  test_util::FakeFileSystem* fake_file_system_;
 
   scoped_ptr<net::TestNetworkDelegate> test_network_delegate_;
   scoped_ptr<TestURLRequestJobFactory> test_url_request_job_factory_;
-  scoped_ptr<net::URLRequestContext> url_request_context_;
-  scoped_ptr<TestDelegate> test_delegate_;
+
+  base::ScopedTempDir temp_dir_;
+  scoped_ptr<TestingPrefServiceSimple> prefs_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
 };
 
 TEST_F(DriveURLRequestJobTest, NonGetMethod) {
   scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("drive:drive/root/File 1.txt"),
       net::DEFAULT_PRIORITY,
       test_delegate_.get(),
       NULL));
   request->set_method("POST");  // Set non "GET" method.
   request->Start();
@@ skipping 187 matching lines @@
       "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 drive