Chrome OS "open with" picker allowing Web Intents

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/chromeos/gdata/drive_task_executor.h"
+#include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/escape.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/isolated_context.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 namespace file_handler_util {
 
@@ skipping 61 matching lines @@
   for (Extension::FileBrowserHandlerList::const_iterator action_iter =
            extension->file_browser_handlers()->begin();
        action_iter != extension->file_browser_handlers()->end();
        ++action_iter) {
     if (action_iter->get()->id() == action_id)
       return action_iter->get();
   }
   return NULL;
 }
 
+bool IsWebIntentAction(const std::string& action_id) {
+  if (action_id.compare(0, 4, std::string("http")) == 0)
+    return true;
+  return false;
+}
+
 unsigned int GetAccessPermissionsForHandler(const Extension* extension,
                                             const std::string& action_id) {
+  if (IsWebIntentAction(action_id))
+    return kReadOnlyFilePermissions;
+
   const FileBrowserHandler* action =
       FindFileBrowserHandler(extension, action_id);
   if (!action)
     return 0;
   unsigned int result = 0;
   if (action->CanRead())
     result |= kReadOnlyFilePermissions;
   if (action->CanWrite())
     result |= kReadWriteFilePermissions;
   // TODO(tbarzic): We don't handle Create yet.
   return result;
 }
 
-
 std::string EscapedUtf8ToLower(const std::string& str) {
   string16 utf16 = UTF8ToUTF16(
       net::UnescapeURLComponent(str, net::UnescapeRule::NORMAL));
   return net::EscapeUrlEncodedData(
       UTF16ToUTF8(base::i18n::ToLower(utf16)),
       false /* do not replace space with plus */);
 }
 
 bool GetFileBrowserHandlers(Profile* profile,
                             const GURL& selected_file_url,
@@ skipping 34 matching lines @@
                                  const LastUsedHandler& b) {
   return a.timestamp > b.timestamp;
 }
 
 // TODO(zelidrag): Wire this with ICU to make this sort I18N happy.
 bool SortByTaskName(const LastUsedHandler& a, const LastUsedHandler& b) {
   return base::strcasecmp(a.handler->title().c_str(),
                           b.handler->title().c_str()) > 0;
 }
 
+// Does this LastUsedHandlerList contain entries with only a common timestamp?
+bool HasCommonTimestamp(LastUsedHandlerList* list) {
+  DCHECK(!list->empty());
+  int common_timestamp = list->begin()->timestamp;
+  for (LastUsedHandlerList::const_iterator iter = list->begin() + 1;
+       iter != list->end(); ++iter) {
+    if (common_timestamp != iter->timestamp)
+      return false;
+  }
+  return true;
+}
+
 void SortLastUsedHandlerList(LastUsedHandlerList *list) {
-  // Sort by the last used descending.
-  std::sort(list->begin(), list->end(), SortByLastUsedTimestampDesc);
-  if (list->size() > 1) {
-    // Sort the rest by name.
+  if (list->size() <= 1) {

[benwells, 2012/08/27 08:02:59]

Could you add a comment to explain the logic used and why it's important? That
is, why we sometimes just sort by name and why we sometimes also sort using the
timestamp.

[thorogood, 2012/08/28 00:04:04]

I've put the comment in front of the if statement, and removed the inline ones.

+    // Ok, we're alreay sorted.
+  } else if (HasCommonTimestamp(list)) {
+    // Sort only by name.
+    std::sort(list->begin(), list->end(), SortByTaskName);
+  } else {
+    // Bring the last used descending to the front, and sort the rest by name.
+    std::sort(list->begin(), list->end(), SortByLastUsedTimestampDesc);
     std::sort(list->begin() + 1, list->end(), SortByTaskName);
   }
 }
 
 }  // namespace
 
 // Update file handler usage stats.
 void UpdateFileHandlerUsageStats(Profile* profile, const std::string& task_id) {
   if (!profile || !profile->GetPrefs())
     return;
@@ skipping 591 matching lines @@
     int handler_pid_in,
     extensions::ExtensionHost* host) {
   int handler_pid = host ? host->render_process_host()->GetID() :
                            handler_pid_in;
 
   if (handler_pid <= 0) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
+  // If we're a Web Intent action (to an extension), short-circuit and deliver
+  // each file as an onLaunched event to the packaged app's background page.
+  if (IsWebIntentAction(action_id_)) {

[benwells, 2012/08/27 08:02:59]

This is a bit of a monster function now. This block should come out into another
function.

[thorogood, 2012/08/29 06:34:46]

I've modified platform_app_launcher to allow launching an app with a path - PTAL
- so this change is now tiny.

+    for (FileDefinitionList::const_iterator iter = file_list.begin();
+         iter != file_list.end(); ++iter) {
+
+      // TODO(thorogood): Literally entirely stolen
+      // from platform_app_launcher.cc, around line 180.
+
+      const FilePath file_path = iter->absolute_path;
+
+      ExtensionProcessManager* process_manager =
+          extensions::ExtensionSystem::Get(profile())->process_manager();
+      extensions::ExtensionHost* host =
+          process_manager->GetBackgroundHostForExtension(extension_id_);
+
+      content::ChildProcessSecurityPolicy* policy =
+          content::ChildProcessSecurityPolicy::GetInstance();
+      int renderer_id = host->render_process_host()->GetID();
+
+      // Granting read file permission to allow reading file content.
+      // If the renderer already has permission to read these paths, it is not
+      // regranted, as this would overwrite any other permissions which the
+      // renderer may already have.
+      if (!policy->CanReadFile(renderer_id, file_path))
+        policy->GrantReadFile(renderer_id, file_path);
+
+      std::string registered_name;
+      fileapi::IsolatedContext* isolated_context =
+          fileapi::IsolatedContext::GetInstance();
+      DCHECK(isolated_context);
+      std::string filesystem_id = isolated_context->RegisterFileSystemForPath(
+          fileapi::kFileSystemTypeIsolated, file_path, &registered_name);
+      // Granting read file system permission as well to allow file-system
+      // read operations.
+      policy->GrantReadFileSystem(renderer_id, filesystem_id);
+
+      extensions::AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
+          profile(),
+          GetExtension(),
+          UTF8ToUTF16(action_id_),
+          filesystem_id,
+          registered_name);
+    }
+
+    ExecuteDoneOnUIThread(true);
+    return;
+  }
+
   extensions::EventRouter* event_router = profile()->GetExtensionEventRouter();
   if (!event_router) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   SetupHandlerHostFileAccessPermissions(handler_pid);
 
   scoped_ptr<ListValue> event_args(new ListValue());
   event_args->Append(Value::CreateStringValue(action_id_));
@@ skipping 71 matching lines @@
         handler_pid,
         handler_host_permissions_[i].first,
         handler_host_permissions_[i].second);
   }
 
   // We don't need this anymore.
   handler_host_permissions_.clear();
 }
 
 } // namespace file_handler_util