Added logic that will return the result of the first chunk of root feed and continue fetching the r…

chrome/browser/chromeos/extensions/file_browser_private_api.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/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 159 matching lines @@
   }
 
   mount_info->SetString("mountCondition",
       DiskMountManager::MountConditionToString(
           mount_point_info.mount_condition));
 
   return mount_info;
 }
 #endif  // defined(OS_CHROMEOS)
 
+
+// Gives the extension renderer |host| file |permissions| for the given |path|.
+void GrantFilePermissionsToHost(content::RenderViewHost* host,
+                                const FilePath& path,
+                                int permissions) {
+  ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
+      host->GetProcess()->GetID(), path, permissions);
+}
+
 // Given a file url, find the virtual FilePath associated with it.
 FilePath GetVirtualPathFromURL(const GURL& file_url) {
   FilePath virtual_path;
   fileapi::FileSystemType type = fileapi::kFileSystemTypeUnknown;
   GURL file_origin_url;
   if (!CrackFileSystemURL(file_url, &file_origin_url, &type, &virtual_path) ||
       type != fileapi::kFileSystemTypeExternal) {
     NOTREACHED();
     return FilePath();
   }
@@ skipping 261 matching lines @@
           this,
           source_url_,
           render_view_host()->GetProcess()->GetID()));
   // Will finish asynchronously.
   return true;
 }
 
 void RequestLocalFileSystemFunction::RespondSuccessOnUIThread(
     const std::string& name, const GURL& root_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Add gdata mount point immediately when we kick of first instance of file
+  // manager. The actual mount event will be sent to UI only when we perform
+  // proper authentication.
+  AddGDataMountPoint();
   result_.reset(new DictionaryValue());
   DictionaryValue* dict = reinterpret_cast<DictionaryValue*>(result_.get());
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
   dict->SetInteger("error", base::PLATFORM_FILE_OK);
   SendResponse(true);
 }
 
+void RequestLocalFileSystemFunction::AddGDataMountPoint() {
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      BrowserContext::GetFileSystemContext(profile_)->external_provider();
+  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
+  if (!provider || provider->HasMountPoint(mount_point))
+    return;
+
+  // Grant R/W permissions to gdata 'folder'. File API layer still
+  // expects this to be satisfied.
+  GrantFilePermissionsToHost(render_view_host(),
+                             mount_point,
+                             file_handler_util::GetReadWritePermissions());
+
+  // Grant R/W permission for tmp and pinned cache folder.
+  gdata::GDataSystemService* system_service =
+      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  DCHECK(system_service);
+  gdata::GDataFileSystem* gdata_file_system = system_service->file_system();
+
+  // We check permissions for raw cache file paths only for read-only
+  // operations (when fileEntry.file() is called), so read only permissions
+  // should be sufficient for all cache paths. For the rest of supported
+  // operations the file access check is done for gdata/ paths.
+  GrantFilePermissionsToHost(render_view_host(),
+                             gdata_file_system->GetGDataCacheTmpDirectory(),
+                             file_handler_util::GetReadOnlyPermissions());
+  GrantFilePermissionsToHost(
+      render_view_host(),
+      gdata_file_system->GetGDataCachePersistentDirectory(),
+      file_handler_util::GetReadOnlyPermissions());
+
+  provider->AddRemoteMountPoint(
+      mount_point,
+      new gdata::GDataFileSystemProxy(gdata_file_system));
+
+  FilePath mount_point_virtual;
+  if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
+    provider->GrantFileAccessToExtension(extension_id(), mount_point_virtual);
+}
+
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
 bool FileWatchBrowserFunctionBase::GetLocalFilePath(
     const GURL& file_url, FilePath* local_path, FilePath* virtual_path) {
   GURL file_origin_url;
@@ skipping 532 matching lines @@
                      this,
                      mount_type_str));
       break;
     }
   }
 #endif  // defined(OS_CHROMEOS)
 
   return true;
 }
 
-void AddMountFunction::GrantFilePermissionsToHost(const FilePath& path,
-                                                  int permissions) {
-  ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-      render_view_host()->GetProcess()->GetID(), path, permissions);
-}
-
-void AddMountFunction::AddGDataMountPoint() {
-  fileapi::ExternalFileSystemMountPointProvider* provider =
-      BrowserContext::GetFileSystemContext(profile_)->external_provider();
-  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
-  if (!provider || provider->HasMountPoint(mount_point))
-    return;
-
-  // Grant R/W permissions to gdata 'folder'. File API layer still
-  // expects this to be satisfied.
-  GrantFilePermissionsToHost(mount_point,
-                             file_handler_util::GetReadWritePermissions());
-
-  // Grant R/W permission for tmp and pinned cache folder.
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
-  DCHECK(system_service);
-  gdata::GDataFileSystem* gdata_file_system = system_service->file_system();
-
-  // We check permissions for raw cache file paths only for read-only
-  // operations (when fileEntry.file() is called), so read only permissions
-  // should be sufficient for all cache paths. For the rest of supported
-  // operations the file access check is done for gdata/ paths.
-  GrantFilePermissionsToHost(gdata_file_system->GetGDataCacheTmpDirectory(),
-                             file_handler_util::GetReadOnlyPermissions());
-  GrantFilePermissionsToHost(
-      gdata_file_system->GetGDataCachePersistentDirectory(),
-      file_handler_util::GetReadOnlyPermissions());
-
-  provider->AddRemoteMountPoint(
-      mount_point,
-      new gdata::GDataFileSystemProxy(gdata_file_system));
-
-  FilePath mount_point_virtual;
-  if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
-    provider->GrantFileAccessToExtension(extension_id(), mount_point_virtual);
-}
-
 void AddMountFunction::RaiseGDataMountEvent(gdata::GDataErrorCode error) {
   chromeos::MountError error_code = error == gdata::HTTP_SUCCESS ?
       chromeos::MOUNT_ERROR_NONE : chromeos::MOUNT_ERROR_NOT_AUTHENTICATED;
   DiskMountManager::MountPointInfo mount_info(
       gdata::util::GetGDataMountPointPathAsString(),
       gdata::util::GetGDataMountPointPathAsString(),
       chromeos::MOUNT_TYPE_GDATA,
       chromeos::disks::MOUNT_CONDITION_NONE);
   // Raise mount event
   FileBrowserEventRouterFactory::GetForProfile(profile_)->
       MountCompleted(DiskMountManager::MOUNTING, error_code, mount_info);
 }
 
 void AddMountFunction::OnGDataAuthentication(gdata::GDataErrorCode error,
                                              const std::string& token) {
-  if (error == gdata::HTTP_SUCCESS)
-    AddGDataMountPoint();
-
   RaiseGDataMountEvent(error);
   SendResponse(true);
 }
 
 void AddMountFunction::GetLocalPathsResponseOnUIThread(
     const std::string& mount_type_str,
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!files.size()) {
@@ skipping 455 matching lines @@
   SET_STRING(IDS_FILE_BROWSER, TAR_GZIP_ARCHIVE_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, PLAIN_TEXT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, PDF_DOCUMENT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, WORD_DOCUMENT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, POWERPOINT_PRESENTATION_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, EXCEL_FILE_TYPE);
 
   SET_STRING(IDS_FILE_BROWSER, GDOC_DOCUMENT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, GSHEET_DOCUMENT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, GSLIDES_DOCUMENT_FILE_TYPE);
-  SET_STRING(IDS_FILE_BROWSER, GSLIDES_DOCUMENT_FILE_TYPE);
+  SET_STRING(IDS_FILE_BROWSER, GDRAW_DOCUMENT_FILE_TYPE);
   SET_STRING(IDS_FILE_BROWSER, GTABLE_DOCUMENT_FILE_TYPE);
 
+
   SET_STRING(IDS_FILE_BROWSER, AUDIO_PLAYER_TITLE);
 #undef SET_STRING
 
   dict->SetString("PDF_VIEW_ENABLED",
       file_manager_util::ShouldBeOpenedWithPdfPlugin(".pdf") ?
           "true" : "false");
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(dict);
 
   if (!profile_->GetPrefs()->GetBoolean(prefs::kDisableGData))
@@ skipping 364 matching lines @@
       local_source_file,
       remote_destination_file,
       base::Bind(&TransferFileFunction::OnTransferCompleted,
                  this));
 }
 
 void TransferFileFunction::OnTransferCompleted(
     base::PlatformFileError error) {
   SendResponse(error == base::PLATFORM_FILE_OK);
 }