Add RemoteFileSyncService interface

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/stl_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/sync_file_system/local_file_sync_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/syncable/sync_status_code.h"
 
 using content::BrowserThread;
 
 namespace sync_file_system {
 
 void SyncFileSystemService::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  pending_providers_.clear();
+  STLDeleteValues(&remote_file_providers_);
+
   local_file_service_->Shutdown();
   local_file_service_.reset();
 
   profile_ = NULL;
 }
 
 SyncFileSystemService::~SyncFileSystemService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!profile_);
+  DCHECK(remote_file_providers_.empty());
+}
+
+void SyncFileSystemService::OnRemoteChangeAvailable(
+    RemoteFileProvider* remote_file_provider) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(remote_file_provider);
+
+  pending_providers_.insert(remote_file_provider);
+  MayStartRemoteSync();
+}
+
+void SyncFileSystemService::RegisterRemoteFileProvider(
+    const std::string& service_name,
+    scoped_ptr<RemoteFileProvider> remote_file_provider) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(remote_file_provider);
+
+  std::pair<RemoteFileProviderMap::iterator, bool> inserted
+      = remote_file_providers_.insert(
+          std::make_pair(service_name, remote_file_provider.get()));
+  if (!inserted.second) {
+    NOTREACHED();
+    pending_providers_.erase(inserted.first->second);
+    delete inserted.first->second;
+    inserted.first->second = remote_file_provider.get();
+  }
+
+  remote_file_provider->SetObserver(this);
+  ignore_result(remote_file_provider.release());
 }
 
 void SyncFileSystemService::InitializeForApp(
     fileapi::FileSystemContext* file_system_context,
     const std::string& service_name,
     const GURL& app_url,
     const StatusCallback& callback) {
-  DCHECK(local_file_service_.get());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(local_file_service_);
 
   // TODO(kinuko,tzik): Instantiate the remote_file_service for the given
   // |service_name| if it hasn't been initialized.
 
   local_file_service_->MaybeInitializeFileSystemContext(
       app_url, file_system_context, callback);
 
-  // TODO(tzik): Hook up remote service initialization code.
+  DCHECK(ContainsKey(remote_file_providers_, service_name) &&
+         remote_file_providers_[service_name]);
+  remote_file_providers_[service_name]->RegisterOrigin(app_url.GetOrigin());
 }
 
 SyncFileSystemService::SyncFileSystemService(Profile* profile)
-    : profile_(profile) {}
+    : profile_(profile),
+      sync_is_running_(false) {}
 
 void SyncFileSystemService::Initialize(
     scoped_ptr<LocalFileSyncService> local_file_service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(local_file_service.get());
+  DCHECK(local_file_service);
   DCHECK(profile_);
 
   local_file_service_ = local_file_service.Pass();
 }
 
+void SyncFileSystemService::MayStartRemoteSync() {

[kinuko, 2012/10/17 09:22:57]

May -> Maybe ?

[tzik, 2012/10/18 07:18:08]

Done.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (sync_is_running_)
+    return;
+
+  RemoteFileProvider* provider = NULL;
+  while (true) {
+    if (pending_providers_.empty())
+      return;
+    provider = *pending_providers_.begin();
+    if (provider->HasRemoteChange())
+      break;
+    else
+      pending_providers_.erase(pending_providers_.begin());
+  }
+  DCHECK(provider);
+
+  sync_is_running_ = true;
+
+  scoped_ptr<RemoteChange> change = provider->GetRemoteChange();
+
+  // TODO(tzik): Disable writing for |url|.
+  fileapi::FileSystemURL url = change->url();
+  if (change->deleted()) {
+    provider->DeleteFile(
+        url, base::Bind(&SyncFileSystemService::DidDeleteFile, AsWeakPtr(),
+                        url));
+  } else {
+    provider->DownloadFile(
+        url,
+        base::Bind(&SyncFileSystemService::DidDownloadFile, AsWeakPtr(),
+                   base::Passed(&change)));
+  }
+}
+
+void SyncFileSystemService::DidDownloadFile(
+    scoped_ptr<RemoteChange> change,
+    fileapi::SyncStatusCode status,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  NOTIMPLEMENTED();
+
+  // TODO(tzik): Do follows on correct thread.
+  // On FILE thread:
+  //   CopyInForeightFile(file_path, change->url());
+  //   DeleteFile(file_path);
+  //
+  // On UI thread:
+  //   remote_file_provider->ChangeApplied(*change);
+  //   EnableWriting(change->url);
+  //   sync_is_running_ = false;
+  //   MayStartRemoteSync();
+}
+
+void SyncFileSystemService::DidDeleteFile(const fileapi::FileSystemURL& url,
+                                          fileapi::SyncStatusCode status) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  sync_is_running_ = false;
+  // Enable writing for |url|.
+  MayStartRemoteSync();
+}
+
 // SyncFileSystemServiceFactory -----------------------------------------------
 
 // static
 SyncFileSystemService* SyncFileSystemServiceFactory::GetForProfile(
     Profile* profile) {
   return static_cast<SyncFileSystemService*>(
       GetInstance()->GetServiceForProfile(profile, true));
 }
 
 // static
@@ skipping 11 matching lines @@
 ProfileKeyedService* SyncFileSystemServiceFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   SyncFileSystemService* service = new SyncFileSystemService(profile);
 
   // TODO(kinuko): Set up mock services if it is called for testing.
 
   scoped_ptr<LocalFileSyncService> local_file_service(
       new LocalFileSyncService);
 
   service->Initialize(local_file_service.Pass());
+
+  // TODO(tzik): Instantiate DriveFileProvider and register it to |service|.
+
   return service;
 }
 
 }  // namespace chrome