[SyncFS] Eliminate SyncFileSystemService dependency from SyncProcessRunner

chrome/browser/sync_file_system/sync_file_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/sync_file_system/sync_file_system_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 129 matching lines @@
 class LocalSyncRunner : public SyncProcessRunner,
                         public LocalFileSyncService::Observer {
  public:
   LocalSyncRunner(const std::string& name,
                   SyncFileSystemService* sync_service)
       : SyncProcessRunner(name, sync_service,
                           scoped_ptr<SyncProcessRunner::TimerHelper>(), 1),
         factory_(this) {}
 
   virtual void StartSync(const SyncStatusCallback& callback) OVERRIDE {
-    sync_service()->local_service_->ProcessLocalChange(
+    GetSyncService()->local_service_->ProcessLocalChange(
         base::Bind(&LocalSyncRunner::DidProcessLocalChange,
                    factory_.GetWeakPtr(), callback));
   }
 
   // LocalFileSyncService::Observer overrides.
   virtual void OnLocalChangeAvailable(int64 pending_changes) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     OnChangesUpdated(pending_changes);
 
     // Kick other sync runners just in case they're not running.
-    sync_service()->RunForEachSyncRunners(
+    GetSyncService()->RunForEachSyncRunners(
         &SyncProcessRunner::ScheduleIfNotRunning);
   }
 
  private:
   void DidProcessLocalChange(
       const SyncStatusCallback& callback,
       SyncStatusCode status,
       const FileSystemURL& url) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "ProcessLocalChange finished with status=%d (%s) for url=%s",
@@ skipping 29 matching lines @@
     return RemoteStateToSyncServiceState(last_state_);
   }
 
   // RemoteFileSyncService::Observer overrides.
   virtual void OnRemoteChangeQueueUpdated(int64 pending_changes) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     OnChangesUpdated(pending_changes);
 
     // Kick other sync runners just in case they're not running.
-    sync_service()->RunForEachSyncRunners(
+    GetSyncService()->RunForEachSyncRunners(
         &SyncProcessRunner::ScheduleIfNotRunning);
   }
 
   virtual void OnRemoteServiceStateUpdated(
       RemoteServiceState state,
       const std::string& description) OVERRIDE {
     // Just forward to SyncFileSystemService.
-    sync_service()->OnRemoteServiceStateUpdated(state, description);
+    GetSyncService()->OnRemoteServiceStateUpdated(state, description);
     last_state_ = state;
   }
 
  private:
   void DidProcessRemoteChange(
       const SyncStatusCallback& callback,
       SyncStatusCode status,
       const FileSystemURL& url) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "ProcessRemoteChange finished with status=%d (%s) for url=%s",
               status, SyncStatusCodeToString(status),
               url.DebugString().c_str());
 
     if (status == SYNC_STATUS_FILE_BUSY) {
-      sync_service()->local_service_->RegisterURLForWaitingSync(
+      GetSyncService()->local_service_->RegisterURLForWaitingSync(
           url, base::Bind(&RemoteSyncRunner::Schedule,
                           factory_.GetWeakPtr()));
     }
     callback.Run(status);
   }
 
   RemoteFileSyncService* remote_service_;
   RemoteServiceState last_state_;
   base::WeakPtrFactory<RemoteSyncRunner> factory_;
   DISALLOW_COPY_AND_ASSIGN(RemoteSyncRunner);
@@ skipping 36 matching lines @@
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "Initializing for App: %s", app_origin.spec().c_str());
 
   local_service_->MaybeInitializeFileSystemContext(
       app_origin, file_system_context,
       base::Bind(&SyncFileSystemService::DidInitializeFileSystem,
                  AsWeakPtr(), app_origin, callback));
 }
 
-SyncServiceState SyncFileSystemService::GetSyncServiceState() {
-  // For now we always query the state from the main RemoteFileSyncService.
-  return RemoteStateToSyncServiceState(remote_service_->GetCurrentState());
-}
-
 void SyncFileSystemService::GetExtensionStatusMap(
     const ExtensionStatusMapCallback& callback) {
   remote_service_->GetOriginStatusMap(
       base::Bind(&SyncFileSystemService::DidGetExtensionStatusMap,
                  AsWeakPtr(), callback));
 }
 
 void SyncFileSystemService::DumpFiles(const GURL& origin,
                                       const DumpFilesCallback& callback) {
   DCHECK(!origin.is_empty());
@@ skipping 42 matching lines @@
 void SyncFileSystemService::RemoveSyncEventObserver(
     SyncEventObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 LocalChangeProcessor* SyncFileSystemService::GetLocalChangeProcessor(
     const GURL& origin) {
   return GetRemoteService(origin)->GetLocalChangeProcessor();
 }
 
+void SyncFileSystemService::OnSyncIdle() {
+  int64 remote_changes = 0;
+  for (ScopedVector<SyncProcessRunner>::iterator iter =
+           remote_sync_runners_.begin();
+       iter != remote_sync_runners_.end(); ++iter)
+    remote_changes += (*iter)->pending_changes();
+  if (remote_changes == 0)
+    local_service_->PromoteDemotedChanges();
+
+  int64 local_changes = 0;
+  for (ScopedVector<SyncProcessRunner>::iterator iter =
+           local_sync_runners_.begin();
+       iter != local_sync_runners_.end(); ++iter)
+    local_changes += (*iter)->pending_changes();
+  if (local_changes == 0 && v2_remote_service_)
+    v2_remote_service_->PromoteDemotedChanges();
+}
+
+SyncServiceState SyncFileSystemService::GetSyncServiceState() {
+  // For now we always query the state from the main RemoteFileSyncService.
+  return RemoteStateToSyncServiceState(remote_service_->GetCurrentState());
+}
+
+SyncFileSystemService* SyncFileSystemService::GetSyncService() {
+  return this;
+}
+
 SyncFileSystemService::SyncFileSystemService(Profile* profile)
     : profile_(profile),
       sync_enabled_(true) {
 }
 
 void SyncFileSystemService::Initialize(
     scoped_ptr<LocalFileSyncService> local_service,
     scoped_ptr<RemoteFileSyncService> remote_service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(local_service);
@@ skipping 203 matching lines @@
 void SyncFileSystemService::DidGetLocalChangeStatus(
     const SyncFileStatusCallback& callback,
     SyncStatusCode status,
     bool has_pending_local_changes) {
   callback.Run(
       status,
       has_pending_local_changes ?
           SYNC_FILE_STATUS_HAS_PENDING_CHANGES : SYNC_FILE_STATUS_SYNCED);
 }
 
-void SyncFileSystemService::OnSyncIdle() {
-  int64 remote_changes = 0;
-  for (ScopedVector<SyncProcessRunner>::iterator iter =
-           remote_sync_runners_.begin();
-       iter != remote_sync_runners_.end(); ++iter)
-    remote_changes += (*iter)->pending_changes();
-  if (remote_changes == 0)
-    local_service_->PromoteDemotedChanges();
-
-  int64 local_changes = 0;
-  for (ScopedVector<SyncProcessRunner>::iterator iter =
-           local_sync_runners_.begin();
-       iter != local_sync_runners_.end(); ++iter)
-    local_changes += (*iter)->pending_changes();
-  if (local_changes == 0 && v2_remote_service_)
-    v2_remote_service_->PromoteDemotedChanges();
-}
-
 void SyncFileSystemService::OnRemoteServiceStateUpdated(
     RemoteServiceState state,
     const std::string& description) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "OnRemoteServiceStateChanged: %d %s", state, description.c_str());
 
   FOR_EACH_OBSERVER(
       SyncEventObserver, observers_,
       OnSyncStateUpdated(GURL(),
@@ skipping 134 matching lines @@
     v2_remote_service_->AddServiceObserver(v2_remote_syncer.get());
     v2_remote_service_->AddFileStatusObserver(this);
     v2_remote_service_->SetRemoteChangeProcessor(local_service_.get());
     v2_remote_service_->SetSyncEnabled(sync_enabled_);
     remote_sync_runners_.push_back(v2_remote_syncer.release());
   }
   return v2_remote_service_.get();
 }
 
 }  // namespace sync_file_system