Merge 22244 - Try again to land: http://codereview.chromium.org/160483...

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2009 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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_file_util.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
-#include "chrome/browser/extensions/theme_preview_infobar_delegate.h"
 #include "chrome/browser/profile.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/extensions/external_registry_extension_provider_win.h"
 #endif
 
 // ExtensionsService.
 
 const char* ExtensionsService::kInstallDirectoryName = "Extensions";
 const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
 
+/*
 const char* ExtensionsService::kGalleryDownloadURLPrefix =
     "https://dl-ssl.google.com/chrome/";
 const char* ExtensionsService::kGalleryURLPrefix =
     "https://tools.google.com/chrome/";
+*/
+const char* ExtensionsService::kGalleryDownloadURLPrefix =
+    "http://www.corp.google.com/~glen/chrome/";
+const char* ExtensionsService::kGalleryURLPrefix =
+    "http://www.corp.google.com/~glen/chrome/";
 
 // static
 bool ExtensionsService::IsDownloadFromGallery(const GURL& download_url,
                                               const GURL& referrer_url) {
   if (StartsWithASCII(download_url.spec(), kGalleryDownloadURLPrefix, false) &&
       StartsWithASCII(referrer_url.spec(), kGalleryURLPrefix, false)) {
     return true;
   } else {
     return false;
   }
@@ skipping 50 matching lines @@
 
   // TODO(erikkay) this should probably be deferred to a future point
   // rather than running immediately at startup.
   CheckForExternalUpdates();
 
   // TODO(erikkay) this should probably be deferred as well.
   GarbageCollectExtensions();
 }
 
 void ExtensionsService::InstallExtension(const FilePath& extension_path) {
-  InstallExtension(extension_path, GURL(), GURL());
-}
-
-void ExtensionsService::InstallExtension(const FilePath& extension_path,
-                                         const GURL& download_url,
-                                         const GURL& referrer_url) {
-  new CrxInstaller(extension_path, install_directory_, Extension::INTERNAL,
-                   "",   // no expected id
-                   extensions_enabled_,
-                   IsDownloadFromGallery(download_url, referrer_url),
-                   show_extensions_prompts(),
-                   false,  // don't delete crx when complete
-                   backend_loop_,
-                   this);
+  CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
+                      "",   // no expected id
+                      false,  // don't delete crx when complete
+                      backend_loop_,
+                      this,
+                      NULL);  // no client (silent install)
 }
 
 void ExtensionsService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path) {
 
   if (!GetExtensionById(id)) {  
     LOG(WARNING) << "Will not update extension " << id << " because it is not "
                  << "installed";        
     return;     
   }
 
-  new CrxInstaller(extension_path, install_directory_, Extension::INTERNAL,
-                   id, extensions_enabled_,
-                   false,  // not from gallery
-                   show_extensions_prompts(),
-                   true,  // delete crx when complete
-                   backend_loop_,
-                   this);
+  CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
+                      id,
+                      true,  // delete crx when complete
+                      backend_loop_,
+                      this,
+                      NULL);  // no client (silent install)
 }
 
 void ExtensionsService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
   Extension* extension = GetExtensionById(extension_id);
 
   // Callers should not send us nonexistant extensions.
   DCHECK(extension);
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
@@ skipping 144 matching lines @@
     }
   }
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension) {
   extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
-    ShowThemePreviewInfobar(extension);
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_INSTALLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 
   // Also load the extension.
   ExtensionList* list = new ExtensionList;
   list->push_back(extension);
   OnExtensionsLoaded(list);
 }
 
 
 void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
   Extension* extension = GetExtensionById(id);
   if (extension && extension->IsTheme()) {
-    ShowThemePreviewInfobar(extension);
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 }
 
 Extension* ExtensionsService::GetExtensionById(const std::string& id) {
   std::string lowercase_id = StringToLowerASCII(id);
   for (ExtensionList::const_iterator iter = extensions_.begin();
@@ skipping 14 matching lines @@
       &ExtensionsServiceBackend::ClearProvidersForTesting));
 }
 
 void ExtensionsService::SetProviderForTesting(
     Extension::Location location, ExternalExtensionProvider* test_provider) {
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::SetProviderForTesting,
       location, test_provider));
 }
 
-bool ExtensionsService::ShowThemePreviewInfobar(Extension* extension) {
-  if (!profile_)
-    return false;
-
-  Browser* browser = BrowserList::GetLastActiveWithProfile(profile_);
-  if (!browser)
-    return false;
-
-  TabContents* tab_contents = browser->GetSelectedTabContents();
-  if (!tab_contents)
-    return false;
-
-  tab_contents->AddInfoBar(new ThemePreviewInfobarDelegate(tab_contents,
-                                                           extension->name()));
-  return true;
-}
-
 void ExtensionsService::OnExternalExtensionFound(const std::string& id,
                                                  const std::string& version,
                                                  const FilePath& path,
                                                  Extension::Location location) {
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get 
   // installed on every startup.
   Extension* existing = GetExtensionById(id);
   if (existing) {
     switch (existing->version()->CompareTo(
                 *Version::GetVersionFromString(version))) {
       case -1:  // existing version is older, we should upgrade
         break;
       case 0:  // existing version is same, do nothing
         return;
       case 1:  // existing version is newer, uh-oh
         LOG(WARNING) << "Found external version of extension " << id
                      << "that is older than current version. Current version "
                      << "is: " << existing->VersionString() << ". New version "
                      << "is: " << version << ". Keeping current version.";
         return;
     }
   }
 
-  new CrxInstaller(path, install_directory_, location, id, extensions_enabled_,
-                   false,  // not from gallery
-                   show_extensions_prompts(),
-                   false,  // don't delete crx when complete
-                   backend_loop_,
-                   this);
+  CrxInstaller::Start(path, install_directory_, location, id,
+                      false,  // don't delete crx when complete
+                      backend_loop_,
+                      this,
+                      NULL);  // no client (silent install)
 }
 
 
 // ExtensionsServicesBackend
 
 ExtensionsServiceBackend::ExtensionsServiceBackend(
     const FilePath& install_directory, MessageLoop* frontend_loop)
         : frontend_(NULL),
           install_directory_(install_directory),
           alert_on_error_(false),
@@ skipping 178 matching lines @@
       linked_ptr<ExternalExtensionProvider>(test_provider);
 }
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(frontend_,
       &ExtensionsService::OnExternalExtensionFound, id, version->GetString(),
       path, location));
 }