Implementation of the "Redirect URLs to Packaged Apps" feature.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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/extensions/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 60 matching lines @@
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/webui/favicon_source.h"
 #include "chrome/browser/ui/webui/ntp/thumbnail_source.h"
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
+#include "chrome/common/extensions/api/url_handlers/url_handlers_parser.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
@@ skipping 33 matching lines @@
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::UnloadedExtensionInfo;
+using extensions::AppEventRouter;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // Histogram values for logging events related to externally installed
 // extensions.
 enum ExternalExtensionEvent {
   EXTERNAL_EXTENSION_INSTALLED = 0,
   EXTERNAL_EXTENSION_IGNORED,
@@ skipping 48 matching lines @@
     "Local Extension Settings";
 const char ExtensionService::kSyncAppSettingsDirectoryName[] =
     "Sync App Settings";
 const char ExtensionService::kSyncExtensionSettingsDirectoryName[] =
     "Sync Extension Settings";
 const char ExtensionService::kManagedSettingsDirectoryName[] =
     "Managed Extension Settings";
 const char ExtensionService::kStateStoreName[] = "Extension State";
 const char ExtensionService::kRulesStoreName[] = "Extension Rules";
 
+bool ExtensionService::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ExtensionService, message)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OnRedirectUrlToApp,
+                        OnRedirectUrlToApp)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     DCHECK(i->get()->IsReady());
     if (i->get()->HasExtension(id))
       return;  // Yup, known extension, don't uninstall.
@@ skipping 2274 matching lines @@
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(*url));
   if (extension && extension->is_platform_app()) {
     *url = GURL(chrome::kExtensionInvalidRequestURL);
     return true;
   }
 
   return false;
 }
 
+bool ExtensionService::MaybeRedirectUrlToApp(const GURL& url,
+                                             const GURL& referrer_url) {
+  // NOTE: The current API spec enforces at most a single app matching a URL.
+  // TODO: Actually implement the above-mentioned enforcement.
+  const extensions::UrlHandlerInfo* handler =
+      extensions_.GetHandlingAppForURL(url);
+  if (handler) {
+    CHECK(handler->app->is_platform_app());
+    extensions::AppEventRouter::DispatchOnLaunchedEventWithURL(
+        profile_, handler->app, handler->id, url, referrer_url);
+    return true;
+  }
+
+  return false;
+}
+
+void ExtensionService::OnRedirectUrlToApp(const std::string& app_id,
+                                          const std::string& handler_id,
+                                          const GURL& url,
+                                          const GURL& referrer_url) {
+  const Extension* app = GetExtensionById(app_id, true);
+  if (app) {
+    CHECK(app->is_platform_app());

[asargent_no_longer_on_chrome, 2013/08/14 18:05:12]

Note that a renderer process could be compromised, so instead of a CHECK here
that crashes the entire browser, it might be more appropriate to kill the
renderer that sent us this IPC message instead. 

(Clearly there are lots more denial-of-service attacks possible from a
compromised renderer, but it's nice not to add another one). 

[sergeygs, 2013/08/18 11:40:24]

After more careful thinking, this should have been a DCHECK from the start,
since it test a design invariant. Changed in the new patch.
On 2013/08/14 18:05:12, Antony Sargent wrote:

+    extensions::AppEventRouter::DispatchOnLaunchedEventWithURL(
+        profile_, app, handler_id, url, referrer_url);
+  }
+}
+
 bool ExtensionService::OnExternalExtensionFileFound(
          const std::string& id,
          const Version* version,
          const base::FilePath& path,
          Manifest::Location location,
          int creation_flags,
          bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
   if (extension_prefs_->IsExternalExtensionUninstalled(id))
@@ skipping 578 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }