Fix flakiness in RemoteFileSystemExtensionApiTests

chrome/browser/chromeos/gdata/gdata_system_service.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_system_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace {
 
+// Used in test to setup system service.
+gdata::DocumentsServiceInterface* g_test_documents_service = NULL;
+const std::string* g_test_cache_root = NULL;
+
 scoped_refptr<base::SequencedTaskRunner> GetTaskRunner(
     const base::SequencedWorkerPool::SequenceToken& sequence_token) {
   return BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
       sequence_token);
 }
 
 }  // nemaspace
 
 namespace gdata {
 
 //===================== GDataSystemService ====================================
 GDataSystemService::GDataSystemService(Profile* profile)
     : profile_(profile),
       sequence_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()),
       cache_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 GDataSystemService::~GDataSystemService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cache_->DestroyOnUIThread();
 }
 
 void GDataSystemService::Initialize(
-    DocumentsServiceInterface* documents_service) {
+    DocumentsServiceInterface* documents_service,
+    const FilePath& cache_root) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_.reset(documents_service);
   cache_ = GDataCache::CreateGDataCacheOnUIThread(
-      GDataCache::GetCacheRootPath(profile_),
+      cache_root,
       GetTaskRunner(sequence_token_));
   uploader_.reset(new GDataUploader(docs_service()));
   webapps_registry_.reset(new DriveWebAppsRegistry);
   file_system_.reset(new GDataFileSystem(profile_,
                                          cache(),
                                          docs_service(),
                                          uploader(),
                                          webapps_registry(),
                                          GetTaskRunner(sequence_token_)));
   download_observer_.reset(new GDataDownloadObserver(uploader(),
@@ skipping 74 matching lines @@
 GDataSystemServiceFactory::GDataSystemServiceFactory()
     : ProfileKeyedServiceFactory("GDataSystemService",
                                  ProfileDependencyManager::GetInstance()) {
   DependsOn(DownloadServiceFactory::GetInstance());
 }
 
 GDataSystemServiceFactory::~GDataSystemServiceFactory() {
 }
 
 // static
-ProfileKeyedService* GDataSystemServiceFactory::CreateInstance(
-    Profile* profile) {
-  return new GDataSystemService(profile);
+void GDataSystemServiceFactory::set_documents_service_for_test(
+    DocumentsServiceInterface* documents_service) {
+  if (g_test_documents_service)
+    delete g_test_documents_service;
+  g_test_documents_service = documents_service;
 }
 
-GDataSystemService*
-GDataSystemServiceFactory::GetWithCustomDocumentsServiceForTesting(
-    Profile* profile,
-    DocumentsServiceInterface* documents_service) {
-  GDataSystemService* service =
-      static_cast<GDataSystemService*>(GetInstance()->SetTestingFactoryAndUse(
-          profile,
-          &GDataSystemServiceFactory::CreateInstance));
-  service->Initialize(documents_service);
-  return service;
+// static
+void GDataSystemServiceFactory::set_cache_root_for_test(
+    const std::string& cache_root) {
+  g_test_cache_root = &cache_root;

[satorux1, 2012/07/21 06:49:13]

this looks unsafe... It assumes that the caller holds the string.

Maybe:

  if (g_test_cache_root)
     delete g_test_cache_root;
  if (!cache_root.empty())
    g_test_cache_root = new std::string(cache_root);

[tbarzic, 2012/07/23 19:38:20]

yeah, Friday is the day for unsafe code :)

Done.

 }
 
 ProfileKeyedService* GDataSystemServiceFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   GDataSystemService* service = new GDataSystemService(profile);
-  service->Initialize(new DocumentsService);
+
+  DocumentsServiceInterface* documents_service =
+      g_test_documents_service ? g_test_documents_service :
+                                 new DocumentsService();
+  g_test_documents_service = NULL;
+  FilePath cache_root =
+      g_test_cache_root ? FilePath(*g_test_cache_root) :
+                          GDataCache::GetCacheRootPath(profile);
+
+  service->Initialize(documents_service, cache_root);
   return service;
 }
 
 }  // namespace gdata