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"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/startup_metric_utils.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/extension_system_notifications.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "extensions/common/error_utils.h"
 #include "googleurl/src/gurl.h"
@@ skipping 17 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 227 matching lines @@
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
                  content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, content::NOTIFICATION_LAUNCH_APP_WITH_URL,
+                 content::NotificationService::AllBrowserContextsAndSources());
   pref_change_registrar_.Init(profile->GetPrefs());
   base::Closure callback =
       base::Bind(&ExtensionService::OnExtensionInstallPrefChanged,
                  base::Unretained(this));
   pref_change_registrar_.Add(prefs::kExtensionInstallAllowList, callback);
   pref_change_registrar_.Add(prefs::kExtensionInstallDenyList, callback);
   pref_change_registrar_.Add(prefs::kExtensionAllowedTypes, callback);
 
   // Set up the ExtensionUpdater
   if (autoupdate_enabled) {
@@ skipping 56 matching lines @@
     ExtensionService::GenerateInstalledExtensionsSet() const {
   scoped_ptr<ExtensionSet> installed_extensions(new ExtensionSet());
   installed_extensions->InsertAll(extensions_);
   installed_extensions->InsertAll(disabled_extensions_);
   installed_extensions->InsertAll(terminated_extensions_);
   installed_extensions->InsertAll(blacklisted_extensions_);
   return installed_extensions.PassAs<const ExtensionSet>();
 }
 
 extensions::PendingExtensionManager*
-    ExtensionService::pending_extension_manager() {
+ExtensionService::pending_extension_manager() {
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
 
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
@@ skipping 2018 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) {
+    DCHECK(handler->app->is_platform_app());
+    extensions::AppEventRouter::DispatchOnLaunchedEventWithURL(
+        profile_, handler->app, handler->id, url, referrer_url);
+    return true;
+  }
+
+  return false;
+}

[not at google - send to devlin, 2013/08/19 23:32:24]

This doesn't need to be in ExtensionService. Pull into a different class.

[sergeygs, 2013/08/29 08:24:42]

Done. The class is PlatformAppRedirector in chrome/browser/extensions.

+
+bool ExtensionService::RedirectUrlToApp(const std::string& app_id,
+                                        const std::string& handler_id,
+                                        const GURL& url,
+                                        const GURL& referrer_url) {
+  // We're just saving some time here by explicitly passing both the url and
+  // the handling app ID here. The original initiator of the app's invocation
+  // (e.g. ChromeContentRendererClient) already has to know this info before
+  // calling us. If the caller doesn't know that, it should use
+  // MaybeRedirectUrlToApp() instead.
+  const Extension* app = GetExtensionById(app_id, true);
+  if (app) {
+    DCHECK(app->is_platform_app() &&
+           app == extensions_.GetHandlingAppForURL(url)->app);
+    extensions::AppEventRouter::DispatchOnLaunchedEventWithURL(
+        profile_, app, handler_id, url, referrer_url);
+    return true;
+  }
+
+  return false;
+}
+
 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 85 matching lines @@
 
   DevToolsAgentHost::ConnectRenderViewHost(iter->second,
                                            host->render_view_host());
   orphaned_dev_tools_.erase(iter);
 }
 
 void ExtensionService::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_APP_TERMINATING:
+    case chrome::NOTIFICATION_APP_TERMINATING: {
       // Shutdown has started. Don't start any more extension installs.
       // (We cannot use ExtensionService::Shutdown() for this because it
       // happens too late in browser teardown.)
       browser_terminating_ = true;
       break;
+    }
+
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
       if (profile_ !=
           content::Source<Profile>(source).ptr()->GetOriginalProfile()) {
         break;
       }
 
       extensions::ExtensionHost* host =
           content::Details<extensions::ExtensionHost>(details).ptr();
 
       // Mark the extension as terminated and Unload it. We want it to
       // be in a consistent state: either fully working or not loaded
       // at all, but never half-crashed.  We do it in a PostTask so
       // that other handlers of this notification will still have
       // access to the Extension and ExtensionHost.
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(
               &ExtensionService::TrackTerminatedExtension,
               AsWeakPtr(),
               host->extension()));
       break;
     }
+
     case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
           break;
 
       // Extensions need to know the channel for API restrictions.
       process->Send(new ExtensionMsg_SetChannel(
@@ skipping 13 matching lines @@
       std::vector<ExtensionMsg_Loaded_Params> loaded_extensions;
       for (ExtensionSet::const_iterator iter = extensions_.begin();
            iter != extensions_.end(); ++iter) {
         // Renderers don't need to know about themes.
         if (!(*iter)->is_theme())
           loaded_extensions.push_back(ExtensionMsg_Loaded_Params(*iter));
       }
       process->Send(new ExtensionMsg_Loaded(loaded_extensions));
       break;
     }
+
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
           break;
 
       process_map_.RemoveAllFromProcess(process->GetID());
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&ExtensionInfoMap::UnregisterAllExtensionsInProcess,
                      system_->info_map(),
                      process->GetID()));
       break;
     }
+
     case chrome::NOTIFICATION_IMPORT_FINISHED: {
       InitAfterImport();
       break;
     }
+
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       extensions::ExtensionHost* host =
           content::Details<extensions::ExtensionHost>(details).ptr();
       std::string extension_id = host->extension_id();
       if (delayed_updates_for_idle_.Contains(extension_id)) {
         // We were waiting for this extension to become idle, it now might have,
         // so maybe finish installation.
         MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&ExtensionService::MaybeFinishDelayedInstallation,
                        AsWeakPtr(), extension_id),
             base::TimeDelta::FromSeconds(kUpdateIdleDelay));
       }
       break;
     }
+
     case chrome::NOTIFICATION_UPGRADE_RECOMMENDED: {
       // Notify extensions that chrome update is available.
       extensions::RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
           profile_);
 
       // Notify observers that chrome update is available.
       FOR_EACH_OBSERVER(extensions::UpdateObserver, update_observers_,
                         OnChromeUpdateAvailable());
       break;
     }
 
+    case content::NOTIFICATION_LAUNCH_APP_WITH_URL: {
+      // Notify the extension system that a navigation has happened whose
+      // target URL was claimed by one of the platform apps, and instruct
+      // it to launch that app.
+      content::LaunchAppWithUrlDetails* launch =
+          content::Details<content::LaunchAppWithUrlDetails>(details).ptr();
+      RedirectUrlToApp(launch->app_id, launch->handler_id,
+                       launch->url, launch->referrer_url);
+      break;
+    }
+
     default:
       NOTREACHED() << "Unexpected notification type.";
   }
 }
 
 void ExtensionService::OnExtensionInstallPrefChanged() {
   IdentifyAlertableExtensions();
   CheckManagementPolicy();
 }
 
@@ skipping 366 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }