Implement new strategy for default apps

chrome/browser/extensions/extensions_service.cc

 // 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.
 
 #include "chrome/browser/extensions/extensions_service.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/crx_installer.h"
+#include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_accessibility_api.h"
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_cookies_api.h"
 #include "chrome/browser/extensions/extension_data_deleter.h"
 #include "chrome/browser/extensions/extension_dom_ui.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_history_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_management_api.h"
@@ skipping 86 matching lines @@
 }
 
 }  // namespace
 
 PendingExtensionInfo::PendingExtensionInfo(
     const GURL& update_url,
     PendingExtensionInfo::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 location)
     : update_url(update_url),
       expected_crx_type(expected_crx_type),
       is_from_sync(is_from_sync),
       install_silently(install_silently),
       enable_on_install(enable_on_install),
-      enable_incognito_on_install(enable_incognito_on_install) {}
+      enable_incognito_on_install(enable_incognito_on_install),
+      install_source(location) {}
 
 PendingExtensionInfo::PendingExtensionInfo()
     : update_url(),
       expected_crx_type(PendingExtensionInfo::UNKNOWN),
       is_from_sync(true),
       install_silently(false),
       enable_on_install(false),
-      enable_incognito_on_install(false) {}
+      enable_incognito_on_install(false),
+      install_source(Extension::INVALID) {}
 
 // ExtensionsService.
 
 const char* ExtensionsService::kInstallDirectoryName = "Extensions";
 const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
 
 // Implements IO for the ExtensionsService.
 
 class ExtensionsServiceBackend
     : public base::RefCountedThreadSafe<ExtensionsServiceBackend>,
@@ skipping 397 matching lines @@
                                      const CommandLine* command_line,
                                      const FilePath& install_directory,
                                      bool autoupdate_enabled)
     : profile_(profile),
       extension_prefs_(new ExtensionPrefs(profile->GetPrefs(),
                                           install_directory)),
       install_directory_(install_directory),
       extensions_enabled_(true),
       show_extensions_prompts_(true),
       ready_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(toolbar_model_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(toolbar_model_(this)),
+      default_apps_(profile->GetPrefs()) {
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
   pref_change_registrar_.Init(profile->GetPrefs());
@@ skipping 100 matching lines @@
   // pending extensions that have install_silently set.
   ExtensionInstallUI* client =
       (!is_pending_extension || it->second.install_silently) ?
       NULL : new ExtensionInstallUI(profile_);
 
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(install_directory_,
                        this,  // frontend
                        client));
   installer->set_expected_id(id);
-  if (is_pending_extension && !it->second.is_from_sync)
-    installer->set_install_source(Extension::EXTERNAL_PREF_DOWNLOAD);
+  installer->set_install_source(it->second.install_source);
   installer->set_delete_source(true);
   installer->set_original_url(download_url);
   installer->InstallCrx(extension_path);
 }
 
 void ExtensionsService::AddPendingExtensionFromSync(
     const std::string& id, const GURL& update_url,
     PendingExtensionInfo::ExpectedCrxType expected_crx_type,
     bool install_silently, bool enable_on_install,
     bool enable_incognito_on_install) {
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add pending extension " << id
                 << " which already exists";
     return;
   }
-  AddPendingExtensionInternal(
-      id, update_url, expected_crx_type, true, install_silently,
-      enable_on_install, enable_incognito_on_install);
+
+  AddPendingExtensionInternal(id, update_url, expected_crx_type, true,
+                              install_silently, enable_on_install,
+                              enable_incognito_on_install,
+                              Extension::INTERNAL);
 }
 
 void ExtensionsService::AddPendingExtensionFromExternalUpdateUrl(
     const std::string& id, const GURL& update_url) {
   // Add the extension to this list of extensions to update.
-  // We do not know if the id refers to a theme, so make is_theme unknown.
   const PendingExtensionInfo::ExpectedCrxType kExpectedCrxType =
       PendingExtensionInfo::UNKNOWN;
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
   const bool kEnableOnInstall = true;
   const bool kEnableIncognitoOnInstall = false;
 
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add extension " << id
                 << " by external update, but it is already installed.";
     return;
   }
 
   AddPendingExtensionInternal(id, update_url, kExpectedCrxType, kIsFromSync,
                               kInstallSilently, kEnableOnInstall,
-                              kEnableIncognitoOnInstall);
+                              kEnableIncognitoOnInstall,
+                              Extension::EXTERNAL_PREF_DOWNLOAD);
+}
+
+void ExtensionsService::AddPendingExtensionFromDefaultAppList(
+    const std::string& id) {
+  // Add the extension to this list of extensions to update.
+  const PendingExtensionInfo::ExpectedCrxType kExpectedCrxType =
+      PendingExtensionInfo::APP;
+  const bool kIsFromSync = false;
+  const bool kInstallSilently = true;
+  const bool kEnableOnInstall = true;
+  const bool kEnableIncognitoOnInstall = true;
+
+  // This can legitimately happen if the user manually installed one of the
+  // default apps before this code ran.
+  if (GetExtensionByIdInternal(id, true, true))
+    return;
+
+  AddPendingExtensionInternal(id, GURL(), kExpectedCrxType, kIsFromSync,
+                              kInstallSilently, kEnableOnInstall,
+                              kEnableIncognitoOnInstall,
+                              Extension::INTERNAL);
 }
 
 void ExtensionsService::AddPendingExtensionInternal(
     const std::string& id, const GURL& update_url,
     PendingExtensionInfo::ExpectedCrxType expected_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) {
   pending_extensions_[id] =
       PendingExtensionInfo(update_url, expected_crx_type, is_from_sync,
                            install_silently, enable_on_install,
-                           enable_incognito_on_install);
+                           enable_incognito_on_install, install_source);
 }
 
 void ExtensionsService::ReloadExtension(const std::string& extension_id) {
   FilePath path;
   Extension* current_extension = GetExtensionById(extension_id, false);
 
   // Disable the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
@@ skipping 726 matching lines @@
   if (it != pending_extensions_.end()) {
     PendingExtensionInfo pending_extension_info = it->second;
     PendingExtensionInfo::ExpectedCrxType expected_crx_type =
         pending_extension_info.expected_crx_type;
     bool is_from_sync = pending_extension_info.is_from_sync;
     pending_extensions_.erase(it);
     it = pending_extensions_.end();
 
     // Set initial state from pending extension data.
     PendingExtensionInfo::ExpectedCrxType actual_crx_type =
-        (extension->is_theme() ? PendingExtensionInfo::THEME
-                               : PendingExtensionInfo::EXTENSION);
+        PendingExtensionInfo::EXTENSION;
+    if (extension->is_app())
+      actual_crx_type = PendingExtensionInfo::APP;
+    else if (extension->is_theme())
+      actual_crx_type = PendingExtensionInfo::THEME;
 
     if (expected_crx_type != PendingExtensionInfo::UNKNOWN &&
         expected_crx_type != actual_crx_type) {
       LOG(WARNING)
           << "Not installing pending extension " << extension->id()
           << " with is_theme = " << extension->is_theme();
       // Delete the extension directory since we're not going to
       // load it.
       ChromeThread::PostTask(
           ChromeThread::FILE, FROM_HERE,
@@ skipping 88 matching lines @@
         NotificationType::THEME_INSTALLED,
         Source<Profile>(profile_),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_INSTALLED,
         Source<Profile>(profile_),
         Details<Extension>(extension));
   }
 
+  if (extension->is_app()) {
+    ExtensionIdSet installed_ids = GetAppIds();
+    installed_ids.insert(extension->id());
+    default_apps_.DidInstallApp(installed_ids);
+  }
+
   // Transfer ownership of |extension| to OnExtensionLoaded.
   OnExtensionLoaded(scoped_extension.release(), allow_privilege_increase);
 }
 
 Extension* ExtensionsService::GetExtensionByIdInternal(const std::string& id,
                                                        bool include_enabled,
                                                        bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     for (ExtensionList::const_iterator iter = extensions_.begin();
@@ skipping 179 matching lines @@
              *pref_name == prefs::kExtensionInstallDenyList);
       CheckAdminBlacklist();
       break;
     }
 
     default:
       NOTREACHED() << "Unexpected notification type.";
   }
 }
 
-bool ExtensionsService::HasApps() {
-  if (!extensions_enabled_)
-    return false;
+bool ExtensionsService::HasApps() const {
+  return !GetAppIds().empty();
+}
 
+ExtensionIdSet ExtensionsService::GetAppIds() const {
+  ExtensionIdSet result;
   for (ExtensionList::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
-    if ((*it)->is_app())
-      return true;
+    if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
+      result.insert((*it)->id());
   }
 
-  return false;
+  return result;
 }