[fsp] Wire FSP to chrome.fileBrowserPrivate.getEntryProperties().

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

 // Copyright 2013 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/extensions/file_manager/private_api_drive.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/file_tasks.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/url_util.h"
+#include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
+#include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/drive/drive_app_registry.h"
 #include "chrome/browser/drive/event_logger.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/auth_service.h"
 #include "webkit/common/fileapi/file_system_info.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 
+using chromeos::file_system_provider::EntryMetadata;
+using chromeos::file_system_provider::ProvidedFileSystemInterface;
+using chromeos::file_system_provider::util::FileSystemURLParser;
+using extensions::api::file_browser_private::EntryProperties;
 using file_manager::util::EntryDefinition;
 using file_manager::util::EntryDefinitionCallback;
 using file_manager::util::EntryDefinitionList;
 using file_manager::util::EntryDefinitionListCallback;
 using file_manager::util::FileDefinition;
 using file_manager::util::FileDefinitionList;
-using extensions::api::file_browser_private::EntryProperties;
 
 namespace extensions {
 namespace {
 
 // List of connection types of drive.
 // Keep this in sync with the DriveConnectionType in common/js/util.js.
 const char kDriveConnectionTypeOffline[] = "offline";
 const char kDriveConnectionTypeMetered[] = "metered";
 const char kDriveConnectionTypeOnline[] = "online";
 
 // List of reasons of kDriveConnectionType*.
 // Keep this in sync with the DriveConnectionReason in common/js/util.js.
 const char kDriveConnectionReasonNotReady[] = "not_ready";
 const char kDriveConnectionReasonNoNetwork[] = "no_network";
 const char kDriveConnectionReasonNoService[] = "no_service";
 
 // Copies properties from |entry_proto| to |properties|. |shared_with_me| is
 // given from the running profile.
-void FillEntryPropertiesValue(const drive::ResourceEntry& entry_proto,
-                              bool shared_with_me,
-                              EntryProperties* properties) {
+void FillEntryPropertiesValueForDrive(const drive::ResourceEntry& entry_proto,
+                                      bool shared_with_me,
+                                      EntryProperties* properties) {
   properties->shared_with_me.reset(new bool(shared_with_me));
   properties->shared.reset(new bool(entry_proto.shared()));
 
   const drive::PlatformFileInfoProto& file_info = entry_proto.file_info();
   properties->file_size.reset(new double(file_info.size()));
   properties->last_modified_time.reset(new double(
       base::Time::FromInternalValue(file_info.last_modified()).ToJsTime()));
 
   if (!entry_proto.has_file_specific_info())
     return;
@@ skipping 87 matching lines @@
     SingleEntryPropertiesGetterForDrive* instance =
         new SingleEntryPropertiesGetterForDrive(local_path, profile, callback);
     instance->StartProcess();
 
     // The instance will be destroyed by itself.
   }
 
   virtual ~SingleEntryPropertiesGetterForDrive() {}
 
  private:
-  // Given parameters.
-  const ResultCallback callback_;
-  const base::FilePath local_path_;
-  Profile* const running_profile_;
-
-  // Values used in the process.
-  scoped_ptr<EntryProperties> properties_;
-  Profile* file_owner_profile_;
-  base::FilePath file_path_;
-  scoped_ptr<drive::ResourceEntry> owner_resource_entry_;
-
-  base::WeakPtrFactory<SingleEntryPropertiesGetterForDrive> weak_ptr_factory_;
-
   SingleEntryPropertiesGetterForDrive(const base::FilePath local_path,
                                       Profile* const profile,
                                       const ResultCallback& callback)
       : callback_(callback),
         local_path_(local_path),
         running_profile_(profile),
         properties_(new EntryProperties),
         file_owner_profile_(NULL),
         weak_ptr_factory_(this) {
     DCHECK(!callback_.is_null());
     DCHECK(profile);
   }
 
-  base::WeakPtr<SingleEntryPropertiesGetterForDrive> GetWeakPtr() {
-    return weak_ptr_factory_.GetWeakPtr();
-  }
-
   void StartProcess() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     file_path_ = drive::util::ExtractDrivePath(local_path_);
     file_owner_profile_ = drive::util::ExtractProfileFromPath(local_path_);
 
     if (!file_owner_profile_ ||
         !g_browser_process->profile_manager()->IsValidProfile(
             file_owner_profile_)) {
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
 
     // Start getting the file info.
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(file_owner_profile_);
     if (!file_system) {
       // |file_system| is NULL if Drive is disabled or not mounted.
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
 
     file_system->GetResourceEntry(
         file_path_,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetFileInfo,
-                   GetWeakPtr()));
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetFileInfo(drive::FileError error,
                      scoped_ptr<drive::ResourceEntry> entry) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
@@ skipping 10 matching lines @@
     // flag from the running profile's value.
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(running_profile_);
     if (!file_system) {
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
     file_system->GetPathFromResourceId(
         owner_resource_entry_->resource_id(),
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetRunningPath,
-                   GetWeakPtr()));
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetRunningPath(drive::FileError error,
                         const base::FilePath& file_path) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     if (error != drive::FILE_ERROR_OK) {
       // The running profile does not know the file.
       StartParseFileInfo(false);
       return;
     }
 
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(running_profile_);
     if (!file_system) {
       // The drive is disable for the running profile.
       StartParseFileInfo(false);
       return;
     }
 
     file_system->GetResourceEntry(
         file_path,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetShareInfo,
-                   GetWeakPtr()));
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetShareInfo(drive::FileError error,
                       scoped_ptr<drive::ResourceEntry> entry) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
 
-    DCHECK(entry);
+    DCHECK(entry.get());
     StartParseFileInfo(entry->shared_with_me());
   }
 
   void StartParseFileInfo(bool shared_with_me) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    FillEntryPropertiesValue(
+    FillEntryPropertiesValueForDrive(
         *owner_resource_entry_, shared_with_me, properties_.get());
 
     drive::FileSystemInterface* const file_system =
         drive::util::GetFileSystemByProfile(file_owner_profile_);
     drive::DriveAppRegistry* const app_registry =
         drive::util::GetDriveAppRegistryByProfile(file_owner_profile_);
     if (!file_system || !app_registry) {
       // |file_system| or |app_registry| is NULL if Drive is disabled.
       CompleteGetEntryProperties(drive::FILE_ERROR_FAILED);
       return;
     }
 
     // The properties meaningful for directories are already filled in
-    // FillEntryPropertiesValue().
+    // FillEntryPropertiesValueForDrive().
     if (!owner_resource_entry_->has_file_specific_info()) {
       CompleteGetEntryProperties(drive::FILE_ERROR_OK);
       return;
     }
 
     const drive::FileSpecificInfo& file_specific_info =
         owner_resource_entry_->file_specific_info();
 
     // Get drive WebApps that can accept this file. We just need to extract the
     // doc icon for the drive app, which is set as default.
@@ skipping 25 matching lines @@
   }
 
   void CompleteGetEntryProperties(drive::FileError error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(!callback_.is_null());
 
     callback_.Run(properties_.Pass(), drive::FileErrorToBaseFileError(error));
 
     delete this;
   }
+
+  // Given parameters.
+  const ResultCallback callback_;
+  const base::FilePath local_path_;
+  Profile* const running_profile_;
+
+  // Values used in the process.
+  scoped_ptr<EntryProperties> properties_;
+  Profile* file_owner_profile_;
+  base::FilePath file_path_;
+  scoped_ptr<drive::ResourceEntry> owner_resource_entry_;
+
+  base::WeakPtrFactory<SingleEntryPropertiesGetterForDrive> weak_ptr_factory_;
+};  // class SingleEntryPropertiesGetterForDrive
+
+class SingleEntryPropertiesGetterForFileSystemProvider {
+ public:
+  typedef base::Callback<void(scoped_ptr<EntryProperties> properties,
+                              base::File::Error error)> ResultCallback;
+
+  // Creates an instance and starts the process.
+  static void Start(const storage::FileSystemURL file_system_url,
+                    const ResultCallback& callback) {

[yoshiki, 2014/09/04 05:29:21]

nit: Please DCHECK if the current thread is the UI. We need to make it sure that
both new and delete are done in the same thread.

[mtomasz, 2014/09/04 06:22:08]

Done.

+    SingleEntryPropertiesGetterForFileSystemProvider* instance =
+        new SingleEntryPropertiesGetterForFileSystemProvider(file_system_url,
+                                                             callback);
+    instance->StartProcess();
+
+    // The instance will be destroyed by itself.
+  }
+
+  virtual ~SingleEntryPropertiesGetterForFileSystemProvider() {}
+
+ private:
+  SingleEntryPropertiesGetterForFileSystemProvider(
+      const storage::FileSystemURL& file_system_url,
+      const ResultCallback& callback)
+      : callback_(callback),
+        file_system_url_(file_system_url),
+        properties_(new EntryProperties),
+        weak_ptr_factory_(this) {
+    DCHECK(!callback_.is_null());
+  }
+
+  void StartProcess() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    FileSystemURLParser parser(file_system_url_);
+    if (!parser.Parse()) {
+      CompleteGetEntryProperties(base::File::FILE_ERROR_NOT_FOUND);
+      return;
+    }
+
+    parser.file_system()->GetMetadata(
+        parser.file_path(),
+        ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL,
+        base::Bind(&SingleEntryPropertiesGetterForFileSystemProvider::
+                       OnGetMetadataCompleted,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  void OnGetMetadataCompleted(scoped_ptr<EntryMetadata> metadata,
+                              base::File::Error result) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    if (result != base::File::FILE_OK) {
+      CompleteGetEntryProperties(result);
+      return;
+    }
+
+    properties_->file_size.reset(new double(metadata->size));
+    properties_->last_modified_time.reset(
+        new double(metadata->modification_time.ToJsTime()));
+
+    if (!metadata->thumbnail.empty())
+      properties_->thumbnail_url.reset(new std::string(metadata->thumbnail));
+
+    CompleteGetEntryProperties(base::File::FILE_OK);
+  }
+
+  void CompleteGetEntryProperties(base::File::Error result) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK(!callback_.is_null());
+
+    callback_.Run(properties_.Pass(), result);
+    delete this;

[yoshiki, 2014/09/04 05:29:21]

Asynchronous delete should be safer.

eg. BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this) 


Because in case of StartProcess -> CompleteGetEntryProperties callpath, the
'parser' variable in StartProcess() method, which uses 'file_system_url_'
property, is free'd after 'this' is deleted. This is not safe.

[mtomasz, 2014/09/04 06:22:08]

Good idea. Done.

+  }
+
+  // Given parameters.
+  const ResultCallback callback_;
+  const storage::FileSystemURL file_system_url_;
+
+  // Values used in the process.
+  scoped_ptr<EntryProperties> properties_;
+
+  base::WeakPtrFactory<SingleEntryPropertiesGetterForFileSystemProvider>
+      weak_ptr_factory_;
 };  // class SingleEntryPropertiesGetterForDrive
 
 }  // namespace
 
 FileBrowserPrivateGetEntryPropertiesFunction::
     FileBrowserPrivateGetEntryPropertiesFunction()
     : processed_count_(0) {
 }
 
 FileBrowserPrivateGetEntryPropertiesFunction::
@@ skipping 20 matching lines @@
       case storage::kFileSystemTypeDrive:
         SingleEntryPropertiesGetterForDrive::Start(
             file_system_url.path(),
             GetProfile(),
             base::Bind(&FileBrowserPrivateGetEntryPropertiesFunction::
                            CompleteGetEntryProperties,
                        this,
                        i));
         break;
       case storage::kFileSystemTypeProvided:
-        // TODO(mtomasz): Add support for provided file systems.
-        NOTIMPLEMENTED();
+        SingleEntryPropertiesGetterForFileSystemProvider::Start(
+            file_system_url,
+            base::Bind(&FileBrowserPrivateGetEntryPropertiesFunction::
+                           CompleteGetEntryProperties,
+                       this,
+                       i));
         break;
       default:
         LOG(ERROR) << "Not supported file system type.";
         CompleteGetEntryProperties(i,
-                                  make_scoped_ptr(new EntryProperties),
-                                  base::File::FILE_ERROR_INVALID_OPERATION);
+                                   make_scoped_ptr(new EntryProperties),
+                                   base::File::FILE_ERROR_INVALID_OPERATION);
     }
   }
 
   return true;
 }
 
 void FileBrowserPrivateGetEntryPropertiesFunction::CompleteGetEntryProperties(
     size_t index,
     scoped_ptr<EntryProperties> properties,
     base::File::Error error) {
@@ skipping 600 matching lines @@
     return;
   }
 
   const std::string url = download_url_ + "?access_token=" + access_token;
   SetResult(new base::StringValue(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions