Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/extensions/webstore_standalone_installer.h"
      6 
      7 #include "base/values.h"
      8 #include "base/version.h"
      9 #include "chrome/browser/extensions/crx_installer.h"
     10 #include "chrome/browser/extensions/extension_install_prompt.h"
     11 #include "chrome/browser/extensions/extension_install_ui.h"
     12 #include "chrome/browser/extensions/extension_install_ui_util.h"
     13 #include "chrome/browser/extensions/extension_service.h"
     14 #include "chrome/browser/extensions/install_tracker.h"
     15 #include "chrome/browser/extensions/webstore_data_fetcher.h"
     16 #include "chrome/browser/profiles/profile.h"
     17 #include "components/crx_file/id_util.h"
     18 #include "content/public/browser/web_contents.h"
     19 #include "extensions/browser/extension_prefs.h"
     20 #include "extensions/browser/extension_registry.h"
     21 #include "extensions/browser/extension_system.h"
     22 #include "extensions/browser/extension_util.h"
     23 #include "extensions/common/extension.h"
     24 #include "extensions/common/extension_urls.h"
     25 #include "url/gurl.h"
     26 
     27 using content::WebContents;
     28 
     29 namespace extensions {
     30 
     31 const char kInvalidWebstoreItemId[] = "Invalid Chrome Web Store item ID";
     32 const char kWebstoreRequestError[] =
     33     "Could not fetch data from the Chrome Web Store";
     34 const char kInvalidWebstoreResponseError[] = "Invalid Chrome Web Store reponse";
     35 const char kInvalidManifestError[] = "Invalid manifest";
     36 const char kUserCancelledError[] = "User cancelled install";
     37 const char kExtensionIsBlacklisted[] = "Extension is blacklisted";
     38 const char kInstallInProgressError[] = "An install is already in progress";
     39 const char kLaunchInProgressError[] = "A launch is already in progress";
     40 
     41 WebstoreStandaloneInstaller::WebstoreStandaloneInstaller(
     42     const std::string& webstore_item_id,
     43     Profile* profile,
     44     const Callback& callback)
     45     : id_(webstore_item_id),
     46       callback_(callback),
     47       profile_(profile),
     48       install_source_(WebstoreInstaller::INSTALL_SOURCE_INLINE),
     49       show_user_count_(true),
     50       average_rating_(0.0),
     51       rating_count_(0) {
     52 }
     53 
     54 void WebstoreStandaloneInstaller::BeginInstall() {
     55   // Add a ref to keep this alive for WebstoreDataFetcher.
     56   // All code paths from here eventually lead to either CompleteInstall or
     57   // AbortInstall, which both release this ref.
     58   AddRef();
     59 
     60   if (!crx_file::id_util::IdIsValid(id_)) {
     61     CompleteInstall(webstore_install::INVALID_ID, kInvalidWebstoreItemId);
     62     return;
     63   }
     64 
     65   webstore_install::Result result = webstore_install::OTHER_ERROR;
     66   std::string error;
     67   if (!EnsureUniqueInstall(&result, &error)) {
     68     CompleteInstall(result, error);
     69     return;
     70   }
     71 
     72   // Use the requesting page as the referrer both since that is more correct
     73   // (it is the page that caused this request to happen) and so that we can
     74   // track top sites that trigger inline install requests.
     75   webstore_data_fetcher_.reset(new WebstoreDataFetcher(
     76       this,
     77       profile_->GetRequestContext(),
     78       GetRequestorURL(),
     79       id_));
     80   webstore_data_fetcher_->Start();
     81 }
     82 
     83 //
     84 // Private interface implementation.
     85 //
     86 
     87 WebstoreStandaloneInstaller::~WebstoreStandaloneInstaller() {
     88 }
     89 
     90 void WebstoreStandaloneInstaller::RunCallback(bool success,
     91                                               const std::string& error,
     92                                               webstore_install::Result result) {
     93   callback_.Run(success, error, result);
     94 }
     95 
     96 void WebstoreStandaloneInstaller::AbortInstall() {
     97   callback_.Reset();
     98   // Abort any in-progress fetches.
     99   if (webstore_data_fetcher_) {
    100     webstore_data_fetcher_.reset();
    101     scoped_active_install_.reset();
    102     Release();  // Matches the AddRef in BeginInstall.
    103   }
    104 }
    105 
    106 bool WebstoreStandaloneInstaller::EnsureUniqueInstall(
    107     webstore_install::Result* reason,
    108     std::string* error) {
    109   InstallTracker* tracker = InstallTracker::Get(profile_);
    110   DCHECK(tracker);
    111 
    112   const ActiveInstallData* existing_install_data =
    113       tracker->GetActiveInstall(id_);
    114   if (existing_install_data) {
    115     if (existing_install_data->is_ephemeral) {
    116       *reason = webstore_install::LAUNCH_IN_PROGRESS;
    117       *error = kLaunchInProgressError;
    118     } else {
    119       *reason = webstore_install::INSTALL_IN_PROGRESS;
    120       *error = kInstallInProgressError;
    121     }
    122     return false;
    123   }
    124 
    125   ActiveInstallData install_data(id_);
    126   InitInstallData(&install_data);
    127   scoped_active_install_.reset(new ScopedActiveInstall(tracker, install_data));
    128   return true;
    129 }
    130 
    131 void WebstoreStandaloneInstaller::CompleteInstall(
    132     webstore_install::Result result,
    133     const std::string& error) {
    134   scoped_active_install_.reset();
    135   if (!callback_.is_null())
    136     callback_.Run(result == webstore_install::SUCCESS, error, result);
    137   Release();  // Matches the AddRef in BeginInstall.
    138 }
    139 
    140 void WebstoreStandaloneInstaller::ProceedWithInstallPrompt() {
    141   install_prompt_ = CreateInstallPrompt();
    142   if (install_prompt_.get()) {
    143     ShowInstallUI();
    144     // Control flow finishes up in InstallUIProceed or InstallUIAbort.
    145   } else {
    146     InstallUIProceed();
    147   }
    148 }
    149 
    150 scoped_refptr<const Extension>
    151 WebstoreStandaloneInstaller::GetLocalizedExtensionForDisplay() {
    152   if (!localized_extension_for_display_.get()) {
    153     DCHECK(manifest_.get());
    154     if (!manifest_.get())
    155       return NULL;
    156 
    157     std::string error;
    158     localized_extension_for_display_ =
    159         ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
    160             manifest_.get(),
    161             Extension::REQUIRE_KEY | Extension::FROM_WEBSTORE,
    162             id_,
    163             localized_name_,
    164             localized_description_,
    165             &error);
    166   }
    167   return localized_extension_for_display_.get();
    168 }
    169 
    170 void WebstoreStandaloneInstaller::InitInstallData(
    171     ActiveInstallData* install_data) const {
    172   // Default implementation sets no properties.
    173 }
    174 
    175 void WebstoreStandaloneInstaller::OnManifestParsed() {
    176   ProceedWithInstallPrompt();
    177 }
    178 
    179 scoped_ptr<ExtensionInstallPrompt>
    180 WebstoreStandaloneInstaller::CreateInstallUI() {
    181   return make_scoped_ptr(new ExtensionInstallPrompt(GetWebContents()));
    182 }
    183 
    184 scoped_ptr<WebstoreInstaller::Approval>
    185 WebstoreStandaloneInstaller::CreateApproval() const {
    186   scoped_ptr<WebstoreInstaller::Approval> approval(
    187       WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
    188           profile_,
    189           id_,
    190           scoped_ptr<base::DictionaryValue>(manifest_.get()->DeepCopy()),
    191           true));
    192   approval->skip_post_install_ui = !ShouldShowPostInstallUI();
    193   approval->use_app_installed_bubble = ShouldShowAppInstalledBubble();
    194   approval->installing_icon = gfx::ImageSkia::CreateFrom1xBitmap(icon_);
    195   return approval.Pass();
    196 }
    197 
    198 void WebstoreStandaloneInstaller::InstallUIProceed() {
    199   if (!CheckRequestorAlive()) {
    200     CompleteInstall(webstore_install::ABORTED, std::string());
    201     return;
    202   }
    203 
    204   scoped_ptr<WebstoreInstaller::Approval> approval = CreateApproval();
    205 
    206   ExtensionService* extension_service =
    207       ExtensionSystem::Get(profile_)->extension_service();
    208   const Extension* installed_extension =
    209       extension_service->GetExtensionById(id_, true /* include disabled */);
    210   if (installed_extension) {
    211     std::string install_message;
    212     webstore_install::Result install_result = webstore_install::SUCCESS;
    213     bool done = true;
    214 
    215     if (ExtensionPrefs::Get(profile_)->IsExtensionBlacklisted(id_)) {
    216       // Don't install a blacklisted extension.
    217       install_result = webstore_install::BLACKLISTED;
    218       install_message = kExtensionIsBlacklisted;
    219     } else if (util::IsEphemeralApp(installed_extension->id(), profile_) &&
    220                !approval->is_ephemeral) {
    221       // If the target extension has already been installed ephemerally and is
    222       // up to date, it can be promoted to a regular installed extension and
    223       // downloading from the Web Store is not necessary.
    224       scoped_refptr<const Extension> extension_to_install =
    225           GetLocalizedExtensionForDisplay();
    226       if (!extension_to_install.get()) {
    227         CompleteInstall(webstore_install::INVALID_MANIFEST,
    228                         kInvalidManifestError);
    229         return;
    230       }
    231 
    232       if (installed_extension->version()->CompareTo(
    233               *extension_to_install->version()) < 0) {
    234         // If the existing extension is out of date, proceed with the install
    235         // to update the extension.
    236         done = false;
    237       } else {
    238         install_ui::ShowPostInstallUIForApproval(
    239             profile_, *approval, installed_extension);
    240         extension_service->PromoteEphemeralApp(installed_extension, false);
    241       }
    242     } else if (!extension_service->IsExtensionEnabled(id_)) {
    243       // If the extension is installed but disabled, and not blacklisted,
    244       // enable it.
    245       extension_service->EnableExtension(id_);
    246     }  // else extension is installed and enabled; no work to be done.
    247 
    248     if (done) {
    249       CompleteInstall(install_result, install_message);
    250       return;
    251     }
    252   }
    253 
    254   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
    255       profile_,
    256       this,
    257       GetWebContents(),
    258       id_,
    259       approval.Pass(),
    260       install_source_);
    261   installer->Start();
    262 }
    263 
    264 void WebstoreStandaloneInstaller::InstallUIAbort(bool user_initiated) {
    265   CompleteInstall(webstore_install::USER_CANCELLED, kUserCancelledError);
    266 }
    267 
    268 void WebstoreStandaloneInstaller::OnWebstoreRequestFailure() {
    269   OnWebStoreDataFetcherDone();
    270   CompleteInstall(webstore_install::WEBSTORE_REQUEST_ERROR,
    271                   kWebstoreRequestError);
    272 }
    273 
    274 void WebstoreStandaloneInstaller::OnWebstoreResponseParseSuccess(
    275     scoped_ptr<base::DictionaryValue> webstore_data) {
    276   OnWebStoreDataFetcherDone();
    277 
    278   if (!CheckRequestorAlive()) {
    279     CompleteInstall(webstore_install::ABORTED, std::string());
    280     return;
    281   }
    282 
    283   std::string error;
    284 
    285   if (!CheckInlineInstallPermitted(*webstore_data, &error)) {
    286     CompleteInstall(webstore_install::NOT_PERMITTED, error);
    287     return;
    288   }
    289 
    290   if (!CheckRequestorPermitted(*webstore_data, &error)) {
    291     CompleteInstall(webstore_install::NOT_PERMITTED, error);
    292     return;
    293   }
    294 
    295   // Manifest, number of users, average rating and rating count are required.
    296   std::string manifest;
    297   if (!webstore_data->GetString(kManifestKey, &manifest) ||
    298       !webstore_data->GetString(kUsersKey, &localized_user_count_) ||
    299       !webstore_data->GetDouble(kAverageRatingKey, &average_rating_) ||
    300       !webstore_data->GetInteger(kRatingCountKey, &rating_count_)) {
    301     CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
    302                     kInvalidWebstoreResponseError);
    303     return;
    304   }
    305 
    306   // Optional.
    307   show_user_count_ = true;
    308   webstore_data->GetBoolean(kShowUserCountKey, &show_user_count_);
    309 
    310   if (average_rating_ < ExtensionInstallPrompt::kMinExtensionRating ||
    311       average_rating_ > ExtensionInstallPrompt::kMaxExtensionRating) {
    312     CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
    313                     kInvalidWebstoreResponseError);
    314     return;
    315   }
    316 
    317   // Localized name and description are optional.
    318   if ((webstore_data->HasKey(kLocalizedNameKey) &&
    319       !webstore_data->GetString(kLocalizedNameKey, &localized_name_)) ||
    320       (webstore_data->HasKey(kLocalizedDescriptionKey) &&
    321       !webstore_data->GetString(
    322           kLocalizedDescriptionKey, &localized_description_))) {
    323     CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
    324                     kInvalidWebstoreResponseError);
    325     return;
    326   }
    327 
    328   // Icon URL is optional.
    329   GURL icon_url;
    330   if (webstore_data->HasKey(kIconUrlKey)) {
    331     std::string icon_url_string;
    332     if (!webstore_data->GetString(kIconUrlKey, &icon_url_string)) {
    333       CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
    334                       kInvalidWebstoreResponseError);
    335       return;
    336     }
    337     icon_url = GURL(extension_urls::GetWebstoreLaunchURL()).Resolve(
    338         icon_url_string);
    339     if (!icon_url.is_valid()) {
    340       CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
    341                       kInvalidWebstoreResponseError);
    342       return;
    343     }
    344   }
    345 
    346   // Assume ownership of webstore_data.
    347   webstore_data_ = webstore_data.Pass();
    348 
    349   scoped_refptr<WebstoreInstallHelper> helper =
    350       new WebstoreInstallHelper(this,
    351                                 id_,
    352                                 manifest,
    353                                 std::string(),  // We don't have any icon data.
    354                                 icon_url,
    355                                 profile_->GetRequestContext());
    356   // The helper will call us back via OnWebstoreParseSucces or
    357   // OnWebstoreParseFailure.
    358   helper->Start();
    359 }
    360 
    361 void WebstoreStandaloneInstaller::OnWebstoreResponseParseFailure(
    362     const std::string& error) {
    363   OnWebStoreDataFetcherDone();
    364   CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE, error);
    365 }
    366 
    367 void WebstoreStandaloneInstaller::OnWebstoreParseSuccess(
    368     const std::string& id,
    369     const SkBitmap& icon,
    370     base::DictionaryValue* manifest) {
    371   CHECK_EQ(id_, id);
    372 
    373   if (!CheckRequestorAlive()) {
    374     CompleteInstall(webstore_install::ABORTED, std::string());
    375     return;
    376   }
    377 
    378   manifest_.reset(manifest);
    379   icon_ = icon;
    380 
    381   OnManifestParsed();
    382 }
    383 
    384 void WebstoreStandaloneInstaller::OnWebstoreParseFailure(
    385     const std::string& id,
    386     InstallHelperResultCode result_code,
    387     const std::string& error_message) {
    388   webstore_install::Result install_result = webstore_install::OTHER_ERROR;
    389   switch (result_code) {
    390     case WebstoreInstallHelper::Delegate::MANIFEST_ERROR:
    391       install_result = webstore_install::INVALID_MANIFEST;
    392       break;
    393     case WebstoreInstallHelper::Delegate::ICON_ERROR:
    394       install_result = webstore_install::ICON_ERROR;
    395       break;
    396     default:
    397       break;
    398   }
    399 
    400   CompleteInstall(install_result, error_message);
    401 }
    402 
    403 void WebstoreStandaloneInstaller::OnExtensionInstallSuccess(
    404     const std::string& id) {
    405   CHECK_EQ(id_, id);
    406   CompleteInstall(webstore_install::SUCCESS, std::string());
    407 }
    408 
    409 void WebstoreStandaloneInstaller::OnExtensionInstallFailure(
    410     const std::string& id,
    411     const std::string& error,
    412     WebstoreInstaller::FailureReason reason) {
    413   CHECK_EQ(id_, id);
    414 
    415   webstore_install::Result install_result = webstore_install::OTHER_ERROR;
    416   switch (reason) {
    417     case WebstoreInstaller::FAILURE_REASON_CANCELLED:
    418       install_result = webstore_install::USER_CANCELLED;
    419       break;
    420     case WebstoreInstaller::FAILURE_REASON_DEPENDENCY_NOT_FOUND:
    421     case WebstoreInstaller::FAILURE_REASON_DEPENDENCY_NOT_SHARED_MODULE:
    422       install_result = webstore_install::MISSING_DEPENDENCIES;
    423       break;
    424     default:
    425       break;
    426   }
    427 
    428   CompleteInstall(install_result, error);
    429 }
    430 
    431 void WebstoreStandaloneInstaller::ShowInstallUI() {
    432   scoped_refptr<const Extension> localized_extension =
    433       GetLocalizedExtensionForDisplay();
    434   if (!localized_extension.get()) {
    435     CompleteInstall(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
    436     return;
    437   }
    438 
    439   install_ui_ = CreateInstallUI();
    440   install_ui_->ConfirmStandaloneInstall(
    441       this, localized_extension.get(), &icon_, install_prompt_);
    442 }
    443 
    444 void WebstoreStandaloneInstaller::OnWebStoreDataFetcherDone() {
    445   // An instance of this class is passed in as a delegate for the
    446   // WebstoreInstallHelper, ExtensionInstallPrompt and WebstoreInstaller, and
    447   // therefore needs to remain alive until they are done. Clear the webstore
    448   // data fetcher to avoid calling Release in AbortInstall while any of these
    449   // operations are in progress.
    450   webstore_data_fetcher_.reset();
    451 }
    452 
    453 }  // namespace extensions
    454