gdata: Move ownership of GDataCache to GDataSystemService

chrome/browser/chromeos/gdata/gdata_sync_client_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/gdata/gdata_sync_client.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 19 matching lines @@
 
 // Action used to set mock expectations for GetFileByResourceId().
 ACTION_P4(MockGetFileByResourceId, error, local_path, mime_type, file_type) {
   arg1.Run(error, local_path, mime_type, file_type);
 }
 
 class GDataSyncClientTest : public testing::Test {
  public:
   GDataSyncClientTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
+        io_thread_(content::BrowserThread::IO),
+        sequence_token_(
+            content::BrowserThread::GetBlockingPool()->GetSequenceToken()),
         profile_(new TestingProfile),
         mock_file_system_(new MockGDataFileSystem),
-        sync_client_(new GDataSyncClient(profile_.get(),
-                                         mock_file_system_.get())),
         mock_network_library_(NULL) {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::CrosLibrary::Initialize(true /* use_stub */);
 
     // CrosLibrary takes ownership of MockNetworkLibrary.
     mock_network_library_ = new chromeos::MockNetworkLibrary;
     chromeos::CrosLibrary::Get()->GetTestApi()->SetNetworkLibrary(
         mock_network_library_, true);
+
+    // Create a temporary directory.
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+
+    // Initialize the sync client.
+    cache_.reset(GDataCache::CreateGDataCache(
+        temp_dir_.path(),
+        content::BrowserThread::GetBlockingPool(),
+        sequence_token_).release());
+    sync_client_.reset(new GDataSyncClient(profile_.get(),
+                                           mock_file_system_.get(),
+                                           cache_.get()));
+
     EXPECT_CALL(*mock_network_library_, AddNetworkManagerObserver(
         sync_client_.get())).Times(1);
     EXPECT_CALL(*mock_network_library_, RemoveNetworkManagerObserver(
         sync_client_.get())).Times(1);
-
-    // Create a temporary directory.
-    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-
     EXPECT_CALL(*mock_file_system_, AddObserver(sync_client_.get()))
         .Times(1);
     EXPECT_CALL(*mock_file_system_, RemoveObserver(sync_client_.get()))
         .Times(1);
 
     sync_client_->Initialize();
   }
 
   virtual void TearDown() OVERRIDE {
     // The sync client should be deleted before NetworkLibrary, as the sync
     // client registers itself as observer of NetworkLibrary.
     sync_client_.reset();
     chromeos::CrosLibrary::Shutdown();
+    content::BrowserThread::GetBlockingPool()
+        ->GetSequencedTaskRunner(sequence_token_)->PostTask(
+            FROM_HERE,
+            base::Bind(&base::DeletePointer<GDataCache>, cache_.release()));
+    RunAllPendingForIO();
+  }
+
+  // Used to wait for the result from an operation that involves file IO,
+  // that runs on the blocking pool thread.
+  void RunAllPendingForIO() {
+    // We should first flush tasks on UI thread, as it can require some
+    // tasks to be run before IO tasks start.
+    message_loop_.RunAllPending();
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    // Once IO tasks are done, flush UI thread again so the results from IO
+    // tasks are processed.
+    message_loop_.RunAllPending();
   }
 
   // Sets up MockNetworkLibrary as if it's connected to wifi network.
   void ConnectToWifi() {
     active_network_.reset(
         chromeos::Network::CreateForTesting(chromeos::TYPE_WIFI));
     EXPECT_CALL(*mock_network_library_, active_network())
         .Times(AnyNumber())
         .WillRepeatedly((Return(active_network_.get())));
     chromeos::Network::TestApi(active_network_.get()).SetConnected(true);
@@ skipping 32 matching lines @@
     EXPECT_CALL(*mock_network_library_, active_network())
         .Times(AnyNumber())
         .WillRepeatedly((Return(active_network_.get())));
     // Here false is passed to make it disconnected.
     chromeos::Network::TestApi(active_network_.get()).SetConnected(false);
     sync_client_->OnNetworkManagerChanged(mock_network_library_);
   }
 
   // Sets up test files in the temporary directory.
   void SetUpTestFiles() {
+    // Create a directory in the temporary directory for pinned files.
+    const FilePath pinned_dir =
+        cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PINNED);
+    ASSERT_TRUE(file_util::CreateDirectory(pinned_dir));
+
     // Create a symlink in the temporary directory to /dev/null.
     // We'll collect this resource ID as a file to be fetched.
     ASSERT_TRUE(
         file_util::CreateSymbolicLink(
             FilePath::FromUTF8Unsafe("/dev/null"),
-            temp_dir_.path().Append("resource_id_not_fetched_foo")));
+            pinned_dir.Append("resource_id_not_fetched_foo")));
     // Create some more.
     ASSERT_TRUE(
         file_util::CreateSymbolicLink(
             FilePath::FromUTF8Unsafe("/dev/null"),
-            temp_dir_.path().Append("resource_id_not_fetched_bar")));
+            pinned_dir.Append("resource_id_not_fetched_bar")));
     ASSERT_TRUE(
         file_util::CreateSymbolicLink(
             FilePath::FromUTF8Unsafe("/dev/null"),
-            temp_dir_.path().Append("resource_id_not_fetched_baz")));
+            pinned_dir.Append("resource_id_not_fetched_baz")));
 
     // Create a symlink in the temporary directory to a test file
     // We won't collect this resource ID, as it already exists.
     FilePath test_data_dir;
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
     FilePath test_file_path = test_data_dir.AppendASCII("chromeos")
         .AppendASCII("gdata").AppendASCII("testfile.txt");
     ASSERT_TRUE(
         file_util::CreateSymbolicLink(
             test_file_path,
-            temp_dir_.path().Append("resource_id_fetched")));
+            pinned_dir.Append("resource_id_fetched")));
   }
 
   // Called when StartInitialScan() is complete.
   void OnInitialScanComplete() {
     message_loop_.Quit();
   }
 
   // Sets the expectation for MockGDataFileSystem::GetFileByResourceId(),
   // that simulates successful retrieval of a file for the given resource ID.
   void SetExpectationForGetFileByResourceId(const std::string& resource_id) {
     EXPECT_CALL(*mock_file_system_,
                 GetFileByResourceId(resource_id, _, _))
         .WillOnce(MockGetFileByResourceId(
             base::PLATFORM_FILE_OK,
             FilePath::FromUTF8Unsafe("local_path_does_not_matter"),
             std::string("mime_type_does_not_matter"),
             REGULAR_FILE));
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread io_thread_;
+  const base::SequencedWorkerPool::SequenceToken sequence_token_;
   ScopedTempDir temp_dir_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<MockGDataFileSystem> mock_file_system_;
+  scoped_ptr<GDataCache> cache_;
   scoped_ptr<GDataSyncClient> sync_client_;
   chromeos::MockNetworkLibrary* mock_network_library_;
   scoped_ptr<chromeos::Network> active_network_;
 };
 
 TEST_F(GDataSyncClientTest, StartInitialScan) {
   SetUpTestFiles();
 
-  EXPECT_CALL(*mock_file_system_, GetCacheDirectoryPath(
-      GDataCache::CACHE_TYPE_PINNED))
-      .WillOnce(Return(temp_dir_.path()));
-
   sync_client_->StartInitialScan(
       base::Bind(&GDataSyncClientTest::OnInitialScanComplete,
                  base::Unretained(this)));
   // Wait until the initial scan is complete.
   message_loop_.Run();
 
   // Check the contents of the queue.
   const std::deque<std::string>& resource_ids =
       sync_client_->GetResourceIdsForTesting();
   ASSERT_EQ(3U, resource_ids.size());
@@ skipping 189 matching lines @@
   ASSERT_EQ(1U, resource_ids.size());
   EXPECT_EQ("resource_id_not_fetched_baz", resource_ids[1]);
 
   sync_client_->OnFileUnpinned("resource_id_not_fetched_baz", "md5");
   // "baz" should be gone.
   resource_ids = sync_client_->GetResourceIdsForTesting();
   ASSERT_TRUE(resource_ids.empty());
 }
 
 }  // namespace gdata