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

chrome/browser/extensions/extension_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 20 matching lines @@
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/extensions/update_observer.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/extensions/manifest.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "ipc/ipc_listener.h"
 #include "sync/api/string_ordinal.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/syncable_service.h"
 
 class CommandLine;
 class ExtensionErrorUI;
 class ExtensionSyncData;
 class ExtensionToolbarModel;
 class GURL;
 class Profile;
@@ skipping 79 matching lines @@
 
   // Returns task runner for crx installation file I/O operations.
   virtual base::SequencedTaskRunner* GetFileTaskRunner() = 0;
 };
 
 // Manages installed and running Chromium extensions.
 class ExtensionService
     : public ExtensionServiceInterface,
       public extensions::ExternalProviderInterface::VisitorInterface,
       public content::NotificationObserver,
-      public extensions::Blacklist::Observer {
+      public extensions::Blacklist::Observer,
+      public IPC::Listener {

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

Since ExtensionService already does a lot of stuff, it's probably better to put
the IPC messaging and associated code in a separate class that just has a
pointer to the owning Profile. 

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

It looks to me now that this attempt wasn't viable anyway. I'm working on an
alternative (will be in the next patch). 
On 2013/08/14 18:05:12, Antony Sargent wrote:

  public:
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char kInstallDirectoryName[];
 
   // If auto-updates are turned on, default to running every 5 hours.
   static const int kDefaultUpdateFrequencySeconds = 60 * 60 * 5;
 
   // The name of the directory inside the profile where per-app local settings
   // are stored.
@@ skipping 250 matching lines @@
 
   // Returns true if |url| should get extension api bindings and be permitted
   // to make api calls. Note that this is independent of what extension
   // permissions the given extension has been granted.
   bool ExtensionBindingsAllowed(const GURL& url);
 
   // Returns true if a normal browser window should avoid showing |url| in a
   // tab. In this case, |url| is also rewritten to an error URL.
   bool ShouldBlockUrlInBrowserTab(GURL* url);
 
+  // Looks if there is a platform app that's registered itself for handling
+  // a URL pattern(s) that matches |url|. If there is, launches the app, using 
+  // the onLaunched event with |url|, |referrerUrl| and the just found
+  // handler ID as launch parameters, and returns true.
+  // Otherwise, returns false.
+  // This direct way of redirecting URLs to apps is for use in browser-
+  // initiated that happen in the browser process (compare to
+  // OnRedirectUrlToApp).
+  bool MaybeRedirectUrlToApp(const GURL& url, const GURL& referrer_url);
+
   // Called when the initial extensions load has completed.
   virtual void OnLoadedInstalledExtensions();
 
   // Adds |extension| to this ExtensionService and notifies observers that the
   // extensions have been loaded.
   virtual void AddExtension(const extensions::Extension* extension) OVERRIDE;
 
   // Check if we have preferences for the component extension and, if not or if
   // the stored version differs, install the extension (without requirements
   // checking) before calling AddExtension.
@@ skipping 252 matching lines @@
   // until the extension is idle. Tests might not like this behavior, so you can
   // disable it with this method.
   void set_install_updates_when_idle_for_test(bool value) {
     install_updates_when_idle_ = value;
   }
 
   // Adds/Removes update observers.
   void AddUpdateObserver(extensions::UpdateObserver* observer);
   void RemoveUpdateObserver(extensions::UpdateObserver* observer);
 
+  // IPC::Listener implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
  private:
   // Contains Extension data that can change during the life of the process,
   // but does not persist across restarts.
   struct ExtensionRuntimeData {
     // True if the background page is ready.
     bool background_page_ready;
 
     // True while the extension is being upgraded.
     bool being_upgraded;
 
@@ skipping 127 matching lines @@
   void OnNeedsToGarbageCollectIsolatedStorage();
 
   // extensions::Blacklist::Observer implementation.
   virtual void OnBlacklistUpdated() OVERRIDE;
 
   // Manages the blacklisted extensions, intended as callback from
   // Blacklist::GetBlacklistedIDs.
   void ManageBlacklist(const std::set<std::string>& old_blacklisted_ids,
                        const std::set<std::string>& new_blacklisted_ids);
 
+  // Launches an app that has |app_id|, using the onLaunched event with
+  // |handler_id|, |url| and |referrerUrl| as launch parameters.
+  // This is registered to listen to the respective IPC control message
+  // from renderer processes to provide a way of redirecting URLs to apps
+  // to them (compare to MaybeRedirectUrlToApp).
+  void OnRedirectUrlToApp(const std::string& app_id,
+                          const std::string& handler_id,
+                          const GURL& url,
+                          const GURL& referrer_url);
+
   // Controls if installs are delayed. See comment for |installs_delayed_|.
   void set_installs_delayed(bool value) { installs_delayed_ = value; }
   bool installs_delayed() const { return installs_delayed_; }
 
   // The normal profile associated with this ExtensionService.
   Profile* profile_;
 
   // The ExtensionSystem for the profile above.
   extensions::ExtensionSystem* system_;
 
@@ skipping 148 matching lines @@
   ObserverList<extensions::UpdateObserver, true> update_observers_;
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_