Drive: Mount/Unmount GoogleDrive on Files App when the file system is mounted/unmounted.

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <set>
 #include <utility>
 
+#include "chrome/browser/chromeos/gdata/gdata_file_system_proxy.h"
+#include "content/public/browser/browser_context.h"
+
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
+#include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_mount_point_provider.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 const FilePath::CharType kAccountMetadataFile[] =
@@ skipping 795 matching lines @@
 
   DCHECK(!update_timer_.IsRunning());
   update_timer_.Start(FROM_HERE,
                       base::TimeDelta::FromSeconds(
                           kGDataUpdateCheckIntervalInSec),
                       base::Bind(&GDataFileSystem::CheckForUpdates,
                           ui_weak_ptr_));
 }
 
 void GDataFileSystem::StopUpdates() {
+  // If unmount request comes from filesystem side, this method may be called
+  // twice. First is just after unmounting on filesystem, second is after
+  // unmounting on filemanager on JS. In other words, if this is called from
+  // GDataFileSystem::RemoveDriveMountPoint(), this will be called again from
+  // FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread().
+  // We choose to stopping updates asynchronous without waiting for filemanager,
+  // rather than waiting for completion of unmounting on filemanager.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(update_timer_.IsRunning());
-  update_timer_.Stop();
+  if (update_timer_.IsRunning())
+    update_timer_.Stop();
 }
 
 void GDataFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByResourceIdOnUIThread,
                  ui_weak_ptr_,
@@ skipping 2016 matching lines @@
 void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LoadRootFeedFromCache(
       false,  // should_load_from_server.
       // search_path doesn't matter if FindEntryCallback parameter is null .
       FilePath(),
       FindEntryCallback());
 }
 
+void GDataFileSystem::AddDriveMountPoint() {
+  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      content::BrowserContext::GetFileSystemContext(profile_)->
+          external_provider();
+  if (provider && !provider->HasMountPoint(mount_point)) {
+    provider->AddRemoteMountPoint(
+        mount_point,
+        new GDataFileSystemProxy(this));

[satorux1, 2012/08/01 20:59:01]

Hmm, why do we need to move the code to GDataFileSystem? We've been trying to
reduce code in GDataFileSystem.

[yoshiki, 2012/08/01 22:23:39]

I moved this code in order to call NotifyFileSystemMounted() and to keep it
private. Do you think it is better to make it public or have good idea?

On 2012/08/01 20:59:01, satorux1 wrote:

[satorux1, 2012/08/02 01:17:12]

What classes are interested in NotifyFileSystemMounted() event? Should this be
an event of GDataFileSystem::Observer? Can we emit this event from eleswhere?

[yoshiki, 2012/08/02 05:53:42]

Sorry for my confusing explanation.

This method (GDataFileSystem::AddDriveMountPoint()) calls
GDataFileSystem::NotifyFileSystemMounted() at L2911, to raise an event to
observers.

If we move this method back to GDataSystemService, we have to change
GDataFileSystem::NotifyFileSystemMounted() a public method. Is it right for you?

On 2012/08/02 01:17:12, satorux1 wrote:

[satorux1, 2012/08/02 06:19:44]

My question was, why NotifyFileSystemMounted() has to be part of
GDataFileSystem::Observer? Who's interested in this event?

[satorux1, 2012/08/02 06:38:32]

I meant:

why OnFileSystemMounted() has to be part of GDataFileSystem::Observer? Who's
interested in this event?


I'm guessing that this event should not belong to GDataFileSystem::Observer. The
class that mounts GDataFileSystem should emit the event?

+    directory_service_.reset(new GDataDirectoryService);
+    NotifyFileSystemMounted();
+  }
+}
+
+void GDataFileSystem::RemoveDriveMountPoint() {
+  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      content::BrowserContext::GetFileSystemContext(profile_)->
+          external_provider();
+  if (provider && provider->HasMountPoint(mount_point)) {
+    NotifyFileSystemUnmounting();
+    // We have to stop update before removing mount point.
+    StopUpdates();
+    provider->RemoveMountPoint(mount_point);
+  }
+}
+
 void GDataFileSystem::OnProtoLoaded(LoadRootFeedParams* params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If we have already received updates from the server, bail out.
   if (directory_service_->origin() == FROM_SERVER)
     return;
 
   int local_changestamp = 0;
   // Update directory structure only if everything is OK and we haven't yet
   // received the feed from the server yet.
@@ skipping 699 matching lines @@
 
 void GDataFileSystem::NotifyDocumentFeedFetched(int num_accumulated_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Document feed fetched: " << num_accumulated_entries;
   // Notify the observers that a document feed is fetched.
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnDocumentFeedFetched(num_accumulated_entries));
 }
 
+void GDataFileSystem::NotifyFileSystemMounted() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "File System is mounted";
+  // Notify the observers that the file system is mounted.
+  FOR_EACH_OBSERVER(Observer, observers_, OnFileSystemMounted());
+}
+
+void GDataFileSystem::NotifyFileSystemUnmounting() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "File System is getting unmounted";
+  // Notify the observers that the file system is getting unmounted.
+  FOR_EACH_OBSERVER(Observer, observers_, OnFileSystemUnmounting());
+}
+
 void GDataFileSystem::RunAndNotifyInitialLoadFinished(
     const FindEntryCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Initial load finished";
   if (!callback.is_null())
     callback.Run(error, entry);
 
@@ skipping 651 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata