Grant file access permissions for cached file paths to file browsers/handlers.

chrome/browser/chromeos/extensions/file_handler_util.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_handler_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 20 matching lines @@
                                       base::PLATFORM_FILE_OPEN_ALWAYS |
                                       base::PLATFORM_FILE_CREATE_ALWAYS |
                                       base::PLATFORM_FILE_OPEN_TRUNCATED |
                                       base::PLATFORM_FILE_READ |
                                       base::PLATFORM_FILE_WRITE |
                                       base::PLATFORM_FILE_EXCLUSIVE_READ |
                                       base::PLATFORM_FILE_EXCLUSIVE_WRITE |
                                       base::PLATFORM_FILE_ASYNC |
                                       base::PLATFORM_FILE_WRITE_ATTRIBUTES;
 
+const int kReadOnlyFilePermissions = base::PLATFORM_FILE_OPEN |
+                                     base::PLATFORM_FILE_READ |
+                                     base::PLATFORM_FILE_EXCLUSIVE_READ |
+                                     base::PLATFORM_FILE_ASYNC;
 
 // Returns process id of the process the extension is running in.
 int ExtractProcessFromExtensionId(const std::string& extension_id,
                                   Profile* profile) {
   GURL extension_url =
       Extension::GetBaseURLFromExtensionId(extension_id);
   ExtensionProcessManager* manager = profile->GetExtensionProcessManager();
 
   SiteInstance* site_instance = manager->GetSiteInstanceForURL(extension_url);
   if (!site_instance || !site_instance->HasProcess())
@@ skipping 97 matching lines @@
     std::sort(list->begin() + 1, list->end(), SortByTaskName);
   }
 }
 
 }  // namespace
 
 int GetReadWritePermissions() {
   return kReadWriteFilePermissions;
 }
 
+int GetReadOnlyPermissions() {
+  return kReadOnlyFilePermissions;
+}
+
 std::string MakeTaskID(const std::string& extension_id,
                        const std::string& action_id) {
   return base::StringPrintf("%s|%s", extension_id.c_str(), action_id.c_str());
 }
 
 // Breaks down task_id that is used between getFileTasks() and executeTask() on
 // its building blocks. task_id field the following structure:
 //     <extension-id>|<task-action-id>
 // Currently, the only supported task-type is of 'context'.
 bool CrackTaskID(const std::string& task_id,
@@ skipping 203 matching lines @@
         external_provider->GetFileSystemRootPathOnFileThread(
           file_origin_url,
           fileapi::kFileSystemTypeExternal,
           virtual_path,
           false);     // create
     FilePath final_file_path = root_path.Append(virtual_path);
 
     // Check if this file system entry exists first.
     base::PlatformFileInfo file_info;
 
-    if (!file_util::PathExists(final_file_path) ||
-        file_util::IsLink(final_file_path) ||
-        !file_util::GetFileInfo(final_file_path, &file_info))
-      return false;
+    bool is_gdata_file = gdata::util::IsUnderGDataMountPoint(final_file_path);
 
-    // TODO(zelidrag): Let's just prevent all symlinks for now. We don't want a
-    // USB drive content to point to something in the rest of the file system.
-    // Ideally, we should permit symlinks within the boundary of the same
-    // virtual mount point.
-    if (file_info.is_symbolic_link)
-      return false;
+    // If the file is under gdata mount point, there is no actual file to be
+    // found on the final_file_path.
+    if (!is_gdata_file) {
+      if (!file_util::PathExists(final_file_path) ||
+          file_util::IsLink(final_file_path) ||
+          !file_util::GetFileInfo(final_file_path, &file_info)) {
+        return false;
+      }
+    }
 
     // TODO(tbarzic): Add explicit R/W + R/O permissions for non-component
     // extensions.
 
     // Grant R/O access permission to non-component extension and R/W to
     // component extensions.
     ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         handler_pid_,
         final_file_path,
         GetReadWritePermissions());
 
+    if (is_gdata_file) {
+      gdata::util::SetPermissionsForGDataCacheFiles(profile_, handler_pid_,
+          final_file_path);
+    }
+
     // Grant access to this particular file to target extension. This will
     // ensure that the target extension can access only this FS entry and
     // prevent from traversing FS hierarchy upward.
     external_provider->GrantFileAccessToExtension(handler_extension_->id(),
                                                   virtual_path);
 
     // Output values.
     GURL target_origin_url(Extension::GetBaseURLFromExtensionId(
         handler_extension_->id()));
     GURL base_url = fileapi::GetFileSystemRootURI(target_origin_url,
@@ skipping 134 matching lines @@
   base::JSONWriter::Write(event_args.get(), &json_args);
   event_router->DispatchEventToExtension(
       extension_id_, std::string("fileBrowserHandler.onExecute"),
       json_args, profile_,
       GURL());
   Done(true);
 }
 
 } // namespace file_handler_util