Implement new strategy for default apps

chrome/browser/extensions/extensions_service.h

 // Copyright (c) 2010 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_EXTENSIONS_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/linked_ptr.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #include "chrome/browser/extensions/extension_menu_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/sandboxed_extension_unpacker.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/common/notification_observer.h"
@@ skipping 11 matching lines @@
 // A pending extension is an extension that hasn't been installed yet
 // and is intended to be installed in the next auto-update cycle.  The
 // update URL of a pending extension may be blank, in which case a
 // default one is assumed.
 struct PendingExtensionInfo {
   // TODO(skerner): Consider merging ExpectedCrxType with
   // browser_sync::ExtensionType.
   enum ExpectedCrxType {
     UNKNOWN,  // Sometimes we don't know the type of a pending item.  An
               // update URL from external_extensions.json is one such case.
+    APP,
     THEME,
     EXTENSION
   };
 
   PendingExtensionInfo(const GURL& update_url,
                        ExpectedCrxType expected_crx_type,
                        bool is_from_sync,
                        bool install_silently,
                        bool enable_on_install,
-                       bool enable_incognito_on_install);
+                       bool enable_incognito_on_install,
+                       Extension::Location install_source);
 
   PendingExtensionInfo();
 
   GURL update_url;
   ExpectedCrxType expected_crx_type;
   bool is_from_sync;  // This update check was initiated from sync.
   bool install_silently;
   bool enable_on_install;
   bool enable_incognito_on_install;
+  Extension::Location install_source;
 };
 
 // A PendingExtensionMap is a map from IDs of pending extensions to
 // their info.
 typedef std::map<std::string, PendingExtensionInfo> PendingExtensionMap;
 
 // This is an interface class to encapsulate the dependencies that
 // ExtensionUpdater has on ExtensionsService. This allows easy mocking.
 class ExtensionUpdateService {
  public:
@@ skipping 79 matching lines @@
   // Registers an extension to be loaded as a component extension.
   void register_component_extension(const ComponentExtensionInfo& info) {
     component_extension_manifests_.push_back(info);
   }
 
   // Returns true if any extensions are installed.
   virtual bool HasInstalledExtensions() {
     return !(extensions_.empty() && disabled_extensions_.empty());
   }
 
+  const FilePath& install_directory() const { return install_directory_; }
+
+  DefaultApps* default_apps() { return &default_apps_; }
+
   // Whether this extension can run in an incognito window.
   bool IsIncognitoEnabled(const Extension* extension);
   void SetIsIncognitoEnabled(Extension* extension, bool enabled);
 
   // Whether this extension can inject scripts into pages with file URLs.
   bool AllowFileAccess(const Extension* extension);
   void SetAllowFileAccess(Extension* extension, bool allow);
 
-  const FilePath& install_directory() const { return install_directory_; }
-
   // Initialize and start all installed extensions.
   void Init();
 
   // Start up the extension event routers.
   void InitEventRouters();
 
   // Look up an extension by ID.
   Extension* GetExtensionById(const std::string& id, bool include_disabled) {
     return GetExtensionByIdInternal(id, true, include_disabled);
   }
@@ skipping 26 matching lines @@
       const std::string& id, const GURL& update_url,
       const PendingExtensionInfo::ExpectedCrxType expected_crx_type,
       bool install_silently, bool enable_on_install,
       bool enable_incognito_on_install);
 
   // Given an extension id and an update URL, schedule the extension
   // to be fetched, installed, and activated.
   void AddPendingExtensionFromExternalUpdateUrl(const std::string& id,
                                                 const GURL& update_url);
 
+  // Like the above. Always installed silently, and defaults update url
+  // from extension id.
+  void AddPendingExtensionFromDefaultAppList(const std::string& id);
+
   // Reloads the specified extension.
   void ReloadExtension(const std::string& extension_id);
 
   // Uninstalls the specified extension. Callers should only call this method
   // with extensions that exist. |external_uninstall| is a magical parameter
   // that is only used to send information to ExtensionPrefs, which external
   // callers should never set to true.
   // TODO(aa): Remove |external_uninstall| -- this information should be passed
   // to ExtensionPrefs some other way.
   void UninstallExtension(const std::string& extension_id,
@@ skipping 141 matching lines @@
 
   // ExtensionHost of background page calls this method right after its render
   // view has been created.
   void DidCreateRenderViewForBackgroundPage(ExtensionHost* host);
 
   // NotificationObserver
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
-  // Whether there are any apps installed.
-  bool HasApps();
+  // Whether there are any apps installed. Component apps are not included.
+  bool HasApps() const;
+
+  // Gets the set of loaded app ids. Component apps are not included.
+  ExtensionIdSet GetAppIds() const;
 
  private:
   virtual ~ExtensionsService();
   friend class ChromeThread;
   friend class DeleteTask<ExtensionsService>;
 
   // Clear all persistent data that may have been stored by the extension.
   void ClearExtensionData(const GURL& extension_url);
 
   // Look up an extension by ID, optionally including either or both of enabled
   // and disabled extensions.
   Extension* GetExtensionByIdInternal(const std::string& id,
                                       bool include_enabled,
                                       bool include_disabled);
 
   // Like AddPendingExtension() but assumes an extension with the same
   // id is not already installed.
   void AddPendingExtensionInternal(
       const std::string& id, const GURL& update_url,
       PendingExtensionInfo::ExpectedCrxType crx_type,
       bool is_from_sync, bool install_silently,
-      bool enable_on_install, bool enable_incognito_on_install);
+      bool enable_on_install, bool enable_incognito_on_install,
+      Extension::Location install_source);
 
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(Extension* extension);
 
   // Handles sending notification that |extension| was unloaded.
   void NotifyExtensionUnloaded(Extension* extension);
 
   // Helper that updates the active extension list used for crash reporting.
   void UpdateActiveExtensionsInCrashReporter();
 
@@ skipping 81 matching lines @@
   // storage within that origin.
   typedef std::map<GURL, int> UnlimitedStorageMap;
   UnlimitedStorageMap unlimited_storage_map_;
 
   // Collection of origins whose storage is protected by "Clear browsing data."
   // A map from origin to the number of Apps currently installed and therefore
   // intrinsically protected.
   typedef std::map<GURL, int> ProtectedStorageMap;
   ProtectedStorageMap protected_storage_map_;
 
+  // Manages the installation of default apps and the promotion of them in the
+  // app launcher.
+  DefaultApps default_apps_;
+
   FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
                            UpdatePendingExtensionAlreadyInstalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionsService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_