Home | History | Annotate | Download | only in extensions 
      1 // Copyright 2013 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/install_verifier.h"
      6 
      7 #include <algorithm>
      8 #include <string>
      9 
     10 #include "base/bind.h"
     11 #include "base/command_line.h"
     12 #include "base/metrics/field_trial.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/prefs/pref_service.h"
     15 #include "base/stl_util.h"
     16 #include "chrome/browser/extensions/extension_service.h"
     17 #include "chrome/browser/extensions/install_signer.h"
     18 #include "chrome/common/chrome_switches.h"
     19 #include "chrome/common/extensions/manifest_url_handler.h"
     20 #include "chrome/common/pref_names.h"
     21 #include "content/public/browser/browser_context.h"
     22 #include "content/public/common/content_switches.h"
     23 #include "extensions/browser/extension_prefs.h"
     24 #include "extensions/browser/extension_registry.h"
     25 #include "extensions/browser/extension_system.h"
     26 #include "extensions/browser/pref_names.h"
     27 #include "extensions/common/extension_set.h"
     28 #include "extensions/common/manifest.h"
     29 #include "extensions/common/one_shot_event.h"
     30 #include "grit/generated_resources.h"
     31 #include "ui/base/l10n/l10n_util.h"
     32 
     33 namespace extensions {
     34 
     35 namespace {
     36 
     37 enum VerifyStatus {
     38   NONE = 0,   // Do not request install signatures, and do not enforce them.
     39   BOOTSTRAP,  // Request install signatures, but do not enforce them.
     40   ENFORCE,    // Request install signatures, and enforce them.
     41   ENFORCE_STRICT,  // Same as ENFORCE, but hard fail if we can't fetch
     42                    // signatures.
     43 
     44   // This is used in histograms - do not remove or reorder entries above! Also
     45   // the "MAX" item below should always be the last element.
     46   VERIFY_STATUS_MAX
     47 };
     48 
     49 #if defined(GOOGLE_CHROME_BUILD)
     50 const char kExperimentName[] = "ExtensionInstallVerification";
     51 #endif  // defined(GOOGLE_CHROME_BUILD)
     52 
     53 VerifyStatus GetExperimentStatus() {
     54 #if defined(GOOGLE_CHROME_BUILD)
     55   const std::string group = base::FieldTrialList::FindFullName(
     56       kExperimentName);
     57 
     58   std::string forced_trials = CommandLine::ForCurrentProcess()->
     59       GetSwitchValueASCII(switches::kForceFieldTrials);
     60   if (forced_trials.find(kExperimentName) != std::string::npos) {
     61     // We don't want to allow turning off enforcement by forcing the field
     62     // trial group to something other than enforcement.
     63     return ENFORCE_STRICT;
     64   }
     65 
     66   VerifyStatus default_status = NONE;
     67 
     68   if (group == "EnforceStrict")
     69     return ENFORCE_STRICT;
     70   else if (group == "Enforce")
     71     return ENFORCE;
     72   else if (group == "Bootstrap")
     73     return BOOTSTRAP;
     74   else if (group == "None" || group == "Control")
     75     return NONE;
     76   else
     77     return default_status;
     78 #endif  // defined(GOOGLE_CHROME_BUILD)
     79 
     80   return NONE;
     81 }
     82 
     83 VerifyStatus GetCommandLineStatus() {
     84   const CommandLine* cmdline = CommandLine::ForCurrentProcess();
     85   if (!InstallSigner::GetForcedNotFromWebstore().empty())
     86     return ENFORCE;
     87 
     88   if (cmdline->HasSwitch(switches::kExtensionsInstallVerification)) {
     89     std::string value = cmdline->GetSwitchValueASCII(
     90         switches::kExtensionsInstallVerification);
     91     if (value == "bootstrap")
     92       return BOOTSTRAP;
     93     else if (value == "enforce_strict")
     94       return ENFORCE_STRICT;
     95     else
     96       return ENFORCE;
     97   }
     98 
     99   return NONE;
    100 }
    101 
    102 VerifyStatus GetStatus() {
    103   return std::max(GetExperimentStatus(), GetCommandLineStatus());
    104 }
    105 
    106 bool ShouldFetchSignature() {
    107   return GetStatus() >= BOOTSTRAP;
    108 }
    109 
    110 bool ShouldEnforce() {
    111   return GetStatus() >= ENFORCE;
    112 }
    113 
    114 enum InitResult {
    115   INIT_NO_PREF = 0,
    116   INIT_UNPARSEABLE_PREF,
    117   INIT_INVALID_SIGNATURE,
    118   INIT_VALID_SIGNATURE,
    119 
    120   // This is used in histograms - do not remove or reorder entries above! Also
    121   // the "MAX" item below should always be the last element.
    122 
    123   INIT_RESULT_MAX
    124 };
    125 
    126 void LogInitResultHistogram(InitResult result) {
    127   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.InitResult",
    128                             result, INIT_RESULT_MAX);
    129 }
    130 
    131 bool FromStore(const Extension& extension) {
    132   if (extension.from_webstore() || ManifestURL::UpdatesFromGallery(&extension))
    133     return true;
    134 
    135   // If an extension has no update url, our autoupdate code will ask the
    136   // webstore about it (to aid in migrating to the webstore from self-hosting
    137   // or sideloading based installs). So we want to do verification checks on
    138   // such extensions too so that we don't accidentally disable old installs of
    139   // extensions that did migrate to the webstore.
    140   return (ManifestURL::GetUpdateURL(&extension).is_empty() &&
    141           Manifest::IsAutoUpdateableLocation(extension.location()));
    142 }
    143 
    144 bool CanUseExtensionApis(const Extension& extension) {
    145   return extension.is_extension() || extension.is_legacy_packaged_app();
    146 }
    147 
    148 enum VerifyAllSuccess {
    149   VERIFY_ALL_BOOTSTRAP_SUCCESS = 0,
    150   VERIFY_ALL_BOOTSTRAP_FAILURE,
    151   VERIFY_ALL_NON_BOOTSTRAP_SUCCESS,
    152   VERIFY_ALL_NON_BOOTSTRAP_FAILURE,
    153 
    154   // Used in histograms. Do not remove/reorder any entries above, and the below
    155   // MAX entry should always come last.
    156   VERIFY_ALL_SUCCESS_MAX
    157 };
    158 
    159 // Record the success or failure of verifying all extensions, and whether or
    160 // not it was a bootstrapping.
    161 void LogVerifyAllSuccessHistogram(bool bootstrap, bool success) {
    162   VerifyAllSuccess result;
    163   if (bootstrap && success)
    164     result = VERIFY_ALL_BOOTSTRAP_SUCCESS;
    165   else if (bootstrap && !success)
    166     result = VERIFY_ALL_BOOTSTRAP_FAILURE;
    167   else if (!bootstrap && success)
    168     result = VERIFY_ALL_NON_BOOTSTRAP_SUCCESS;
    169   else
    170     result = VERIFY_ALL_NON_BOOTSTRAP_FAILURE;
    171 
    172   // This used to be part of ExtensionService, but moved here. In order to keep
    173   // our histograms accurate, the name is unchanged.
    174   UMA_HISTOGRAM_ENUMERATION(
    175       "ExtensionService.VerifyAllSuccess", result, VERIFY_ALL_SUCCESS_MAX);
    176 }
    177 
    178 // Record the success or failure of a single verification.
    179 void LogAddVerifiedSuccess(bool success) {
    180   // This used to be part of ExtensionService, but moved here. In order to keep
    181   // our histograms accurate, the name is unchanged.
    182   UMA_HISTOGRAM_BOOLEAN("ExtensionService.AddVerified", success);
    183 }
    184 
    185 }  // namespace
    186 
    187 InstallVerifier::InstallVerifier(ExtensionPrefs* prefs,
    188                                  content::BrowserContext* context)
    189     : prefs_(prefs),
    190       context_(context),
    191       bootstrap_check_complete_(false),
    192       weak_factory_(this) {
    193 }
    194 
    195 InstallVerifier::~InstallVerifier() {}
    196 
    197 // static
    198 bool InstallVerifier::NeedsVerification(const Extension& extension) {
    199   return FromStore(extension) && CanUseExtensionApis(extension);
    200 }
    201 
    202 void InstallVerifier::Init() {
    203   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ExperimentStatus",
    204                             GetExperimentStatus(), VERIFY_STATUS_MAX);
    205   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ActualStatus",
    206                             GetStatus(), VERIFY_STATUS_MAX);
    207 
    208   const base::DictionaryValue* pref = prefs_->GetInstallSignature();
    209   if (pref) {
    210     scoped_ptr<InstallSignature> signature_from_prefs =
    211         InstallSignature::FromValue(*pref);
    212     if (!signature_from_prefs.get()) {
    213       LogInitResultHistogram(INIT_UNPARSEABLE_PREF);
    214     } else if (!InstallSigner::VerifySignature(*signature_from_prefs.get())) {
    215       LogInitResultHistogram(INIT_INVALID_SIGNATURE);
    216       DVLOG(1) << "Init - ignoring invalid signature";
    217     } else {
    218       signature_ = signature_from_prefs.Pass();
    219       LogInitResultHistogram(INIT_VALID_SIGNATURE);
    220       UMA_HISTOGRAM_COUNTS_100("ExtensionInstallVerifier.InitSignatureCount",
    221                                signature_->ids.size());
    222       GarbageCollect();
    223     }
    224   } else {
    225     LogInitResultHistogram(INIT_NO_PREF);
    226   }
    227 
    228   ExtensionSystem::Get(context_)->ready().Post(
    229       FROM_HERE,
    230       base::Bind(&InstallVerifier::MaybeBootstrapSelf,
    231                  weak_factory_.GetWeakPtr()));
    232 }
    233 
    234 void InstallVerifier::VerifyAllExtensions() {
    235   AddMany(GetExtensionsToVerify(), ADD_ALL);
    236 }
    237 
    238 base::Time InstallVerifier::SignatureTimestamp() {
    239   if (signature_.get())
    240     return signature_->timestamp;
    241   else
    242     return base::Time();
    243 }
    244 
    245 bool InstallVerifier::IsKnownId(const std::string& id) {
    246   return signature_.get() && (ContainsKey(signature_->ids, id) ||
    247                               ContainsKey(signature_->invalid_ids, id));
    248 }
    249 
    250 void InstallVerifier::VerifyExtension(const std::string& extension_id) {
    251   ExtensionIdSet ids;
    252   ids.insert(extension_id);
    253   AddMany(ids, ADD_SINGLE);
    254 }
    255 
    256 void InstallVerifier::AddMany(const ExtensionIdSet& ids, OperationType type) {
    257   if (!ShouldFetchSignature()) {
    258     OnVerificationComplete(true, type);  // considered successful.
    259     return;
    260   }
    261 
    262   if (signature_.get()) {
    263     ExtensionIdSet not_allowed_yet =
    264         base::STLSetDifference<ExtensionIdSet>(ids, signature_->ids);
    265     if (not_allowed_yet.empty()) {
    266       OnVerificationComplete(true, type);  // considered successful.
    267       return;
    268     }
    269   }
    270 
    271   InstallVerifier::PendingOperation* operation =
    272       new InstallVerifier::PendingOperation(type);
    273   operation->ids.insert(ids.begin(), ids.end());
    274 
    275   operation_queue_.push(linked_ptr<PendingOperation>(operation));
    276 
    277   // If there are no ongoing pending requests, we need to kick one off.
    278   if (operation_queue_.size() == 1)
    279     BeginFetch();
    280 }
    281 
    282 void InstallVerifier::AddProvisional(const ExtensionIdSet& ids) {
    283   provisional_.insert(ids.begin(), ids.end());
    284   AddMany(ids, ADD_PROVISIONAL);
    285 }
    286 
    287 void InstallVerifier::Remove(const std::string& id) {
    288   ExtensionIdSet ids;
    289   ids.insert(id);
    290   RemoveMany(ids);
    291 }
    292 
    293 void InstallVerifier::RemoveMany(const ExtensionIdSet& ids) {
    294   if (!signature_.get() || !ShouldFetchSignature())
    295     return;
    296 
    297   bool found_any = false;
    298   for (ExtensionIdSet::const_iterator i = ids.begin(); i != ids.end(); ++i) {
    299     if (ContainsKey(signature_->ids, *i) ||
    300         ContainsKey(signature_->invalid_ids, *i)) {
    301       found_any = true;
    302       break;
    303     }
    304   }
    305   if (!found_any)
    306     return;
    307 
    308   InstallVerifier::PendingOperation* operation =
    309       new InstallVerifier::PendingOperation(InstallVerifier::REMOVE);
    310   operation->ids = ids;
    311 
    312   operation_queue_.push(linked_ptr<PendingOperation>(operation));
    313   if (operation_queue_.size() == 1)
    314     BeginFetch();
    315 }
    316 
    317 std::string InstallVerifier::GetDebugPolicyProviderName() const {
    318   return std::string("InstallVerifier");
    319 }
    320 
    321 namespace {
    322 
    323 enum MustRemainDisabledOutcome {
    324   VERIFIED = 0,
    325   NOT_EXTENSION,
    326   UNPACKED,
    327   ENTERPRISE_POLICY_ALLOWED,
    328   FORCED_NOT_VERIFIED,
    329   NOT_FROM_STORE,
    330   NO_SIGNATURE,
    331   NOT_VERIFIED_BUT_NOT_ENFORCING,
    332   NOT_VERIFIED,
    333   NOT_VERIFIED_BUT_INSTALL_TIME_NEWER_THAN_SIGNATURE,
    334   NOT_VERIFIED_BUT_UNKNOWN_ID,
    335   COMPONENT,
    336 
    337   // This is used in histograms - do not remove or reorder entries above! Also
    338   // the "MAX" item below should always be the last element.
    339   MUST_REMAIN_DISABLED_OUTCOME_MAX
    340 };
    341 
    342 void MustRemainDisabledHistogram(MustRemainDisabledOutcome outcome) {
    343   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.MustRemainDisabled",
    344                             outcome, MUST_REMAIN_DISABLED_OUTCOME_MAX);
    345 }
    346 
    347 }  // namespace
    348 
    349 bool InstallVerifier::MustRemainDisabled(const Extension* extension,
    350                                          Extension::DisableReason* reason,
    351                                          base::string16* error) const {
    352   CHECK(extension);
    353   if (!CanUseExtensionApis(*extension)) {
    354     MustRemainDisabledHistogram(NOT_EXTENSION);
    355     return false;
    356   }
    357   if (Manifest::IsUnpackedLocation(extension->location())) {
    358     MustRemainDisabledHistogram(UNPACKED);
    359     return false;
    360   }
    361   if (extension->location() == Manifest::COMPONENT) {
    362     MustRemainDisabledHistogram(COMPONENT);
    363     return false;
    364   }
    365   if (AllowedByEnterprisePolicy(extension->id())) {
    366     MustRemainDisabledHistogram(ENTERPRISE_POLICY_ALLOWED);
    367     return false;
    368   }
    369 
    370   bool verified = true;
    371   MustRemainDisabledOutcome outcome = VERIFIED;
    372   if (ContainsKey(InstallSigner::GetForcedNotFromWebstore(), extension->id())) {
    373     verified = false;
    374     outcome = FORCED_NOT_VERIFIED;
    375   } else if (!FromStore(*extension)) {
    376     verified = false;
    377     outcome = NOT_FROM_STORE;
    378   } else if (signature_.get() == NULL &&
    379              (!bootstrap_check_complete_ || GetStatus() < ENFORCE_STRICT)) {
    380     // If we don't have a signature yet, we'll temporarily consider every
    381     // extension from the webstore verified to avoid false positives on existing
    382     // profiles hitting this code for the first time. The InstallVerifier
    383     // will bootstrap itself once the ExtensionsSystem is ready.
    384     outcome = NO_SIGNATURE;
    385   } else if (!IsVerified(extension->id())) {
    386     if (signature_.get() &&
    387         !ContainsKey(signature_->invalid_ids, extension->id())) {
    388       outcome = NOT_VERIFIED_BUT_UNKNOWN_ID;
    389     } else {
    390       verified = false;
    391       outcome = NOT_VERIFIED;
    392     }
    393   }
    394   if (!verified && !ShouldEnforce()) {
    395     verified = true;
    396     outcome = NOT_VERIFIED_BUT_NOT_ENFORCING;
    397   }
    398   MustRemainDisabledHistogram(outcome);
    399 
    400   if (!verified) {
    401     if (reason)
    402       *reason = Extension::DISABLE_NOT_VERIFIED;
    403     if (error)
    404       *error = l10n_util::GetStringFUTF16(
    405           IDS_EXTENSIONS_ADDED_WITHOUT_KNOWLEDGE,
    406           l10n_util::GetStringUTF16(IDS_EXTENSION_WEB_STORE_TITLE));
    407   }
    408   return !verified;
    409 }
    410 
    411 InstallVerifier::PendingOperation::PendingOperation(OperationType type)
    412     : type(type) {}
    413 
    414 InstallVerifier::PendingOperation::~PendingOperation() {
    415 }
    416 
    417 ExtensionIdSet InstallVerifier::GetExtensionsToVerify() const {
    418   ExtensionIdSet result;
    419   scoped_ptr<ExtensionSet> extensions =
    420       ExtensionRegistry::Get(context_)->GenerateInstalledExtensionsSet();
    421   for (ExtensionSet::const_iterator iter = extensions->begin();
    422        iter != extensions->end();
    423        ++iter) {
    424     if (NeedsVerification(**iter))
    425       result.insert((*iter)->id());
    426   }
    427   return result;
    428 }
    429 
    430 void InstallVerifier::MaybeBootstrapSelf() {
    431   bool needs_bootstrap = false;
    432 
    433   ExtensionIdSet extension_ids = GetExtensionsToVerify();
    434   if (signature_.get() == NULL && ShouldFetchSignature()) {
    435     needs_bootstrap = true;
    436   } else {
    437     for (ExtensionIdSet::const_iterator iter = extension_ids.begin();
    438          iter != extension_ids.end();
    439          ++iter) {
    440       if (!IsKnownId(*iter)) {
    441         needs_bootstrap = true;
    442         break;
    443       }
    444     }
    445   }
    446 
    447   if (needs_bootstrap)
    448     AddMany(extension_ids, ADD_ALL_BOOTSTRAP);
    449   else
    450     bootstrap_check_complete_ = true;
    451 }
    452 
    453 void InstallVerifier::OnVerificationComplete(bool success, OperationType type) {
    454   switch (type) {
    455     case ADD_SINGLE:
    456       LogAddVerifiedSuccess(success);
    457       break;
    458     case ADD_ALL:
    459     case ADD_ALL_BOOTSTRAP:
    460       LogVerifyAllSuccessHistogram(type == ADD_ALL_BOOTSTRAP, success);
    461       bootstrap_check_complete_ = true;
    462       if (success) {
    463         // Iterate through the extensions and, if any are newly-verified and
    464         // should have the DISABLE_NOT_VERIFIED reason lifted, do so.
    465         const ExtensionSet& disabled_extensions =
    466             ExtensionRegistry::Get(context_)->disabled_extensions();
    467         for (ExtensionSet::const_iterator iter = disabled_extensions.begin();
    468              iter != disabled_extensions.end();
    469              ++iter) {
    470           int disable_reasons = prefs_->GetDisableReasons((*iter)->id());
    471           if (disable_reasons & Extension::DISABLE_NOT_VERIFIED &&
    472               !MustRemainDisabled(*iter, NULL, NULL)) {
    473             prefs_->RemoveDisableReason((*iter)->id(),
    474                                         Extension::DISABLE_NOT_VERIFIED);
    475           }
    476         }
    477       }
    478       if (success || GetStatus() == ENFORCE_STRICT) {
    479         ExtensionSystem::Get(context_)
    480             ->extension_service()
    481             ->CheckManagementPolicy();
    482       }
    483       break;
    484     // We don't need to check disable reasons or report UMA stats for
    485     // provisional adds or removals.
    486     case ADD_PROVISIONAL:
    487     case REMOVE:
    488       break;
    489   }
    490 }
    491 
    492 void InstallVerifier::GarbageCollect() {
    493   if (!ShouldFetchSignature()) {
    494     return;
    495   }
    496   CHECK(signature_.get());
    497   ExtensionIdSet leftovers = signature_->ids;
    498   leftovers.insert(signature_->invalid_ids.begin(),
    499                    signature_->invalid_ids.end());
    500   ExtensionIdList all_ids;
    501   prefs_->GetExtensions(&all_ids);
    502   for (ExtensionIdList::const_iterator i = all_ids.begin();
    503        i != all_ids.end(); ++i) {
    504     ExtensionIdSet::iterator found = leftovers.find(*i);
    505     if (found != leftovers.end())
    506       leftovers.erase(found);
    507   }
    508   if (!leftovers.empty()) {
    509     RemoveMany(leftovers);
    510   }
    511 }
    512 
    513 bool InstallVerifier::AllowedByEnterprisePolicy(const std::string& id) const {
    514   PrefService* pref_service = prefs_->pref_service();
    515   if (pref_service->IsManagedPreference(pref_names::kInstallAllowList)) {
    516     const base::ListValue* whitelist =
    517         pref_service->GetList(pref_names::kInstallAllowList);
    518     base::StringValue id_value(id);
    519     if (whitelist && whitelist->Find(id_value) != whitelist->end())
    520       return true;
    521   }
    522   if (pref_service->IsManagedPreference(pref_names::kInstallForceList)) {
    523     const base::DictionaryValue* forcelist =
    524         pref_service->GetDictionary(pref_names::kInstallForceList);
    525     if (forcelist && forcelist->HasKey(id))
    526       return true;
    527   }
    528   return false;
    529 }
    530 
    531 bool InstallVerifier::IsVerified(const std::string& id) const {
    532   return ((signature_.get() && ContainsKey(signature_->ids, id)) ||
    533           ContainsKey(provisional_, id));
    534 }
    535 
    536 void InstallVerifier::BeginFetch() {
    537   DCHECK(ShouldFetchSignature());
    538 
    539   // TODO(asargent) - It would be possible to coalesce all operations in the
    540   // queue into one fetch - we'd probably just need to change the queue to
    541   // hold (set of ids, list of operation type) pairs.
    542   CHECK(!operation_queue_.empty());
    543   const PendingOperation& operation = *operation_queue_.front();
    544 
    545   ExtensionIdSet ids_to_sign;
    546   if (signature_.get()) {
    547     ids_to_sign.insert(signature_->ids.begin(), signature_->ids.end());
    548   }
    549   if (operation.type == InstallVerifier::REMOVE) {
    550     for (ExtensionIdSet::const_iterator i = operation.ids.begin();
    551          i != operation.ids.end(); ++i) {
    552       if (ContainsKey(ids_to_sign, *i))
    553         ids_to_sign.erase(*i);
    554     }
    555   } else {  // All other operation types are some form of "ADD".
    556     ids_to_sign.insert(operation.ids.begin(), operation.ids.end());
    557   }
    558 
    559   signer_.reset(new InstallSigner(context_->GetRequestContext(), ids_to_sign));
    560   signer_->GetSignature(base::Bind(&InstallVerifier::SignatureCallback,
    561                                    weak_factory_.GetWeakPtr()));
    562 }
    563 
    564 void InstallVerifier::SaveToPrefs() {
    565   if (signature_.get())
    566     DCHECK(InstallSigner::VerifySignature(*signature_));
    567 
    568   if (!signature_.get() || signature_->ids.empty()) {
    569     DVLOG(1) << "SaveToPrefs - saving NULL";
    570     prefs_->SetInstallSignature(NULL);
    571   } else {
    572     base::DictionaryValue pref;
    573     signature_->ToValue(&pref);
    574     if (VLOG_IS_ON(1)) {
    575       DVLOG(1) << "SaveToPrefs - saving";
    576 
    577       DCHECK(InstallSigner::VerifySignature(*signature_.get()));
    578       scoped_ptr<InstallSignature> rehydrated =
    579           InstallSignature::FromValue(pref);
    580       DCHECK(InstallSigner::VerifySignature(*rehydrated.get()));
    581     }
    582     prefs_->SetInstallSignature(&pref);
    583   }
    584 }
    585 
    586 namespace {
    587 
    588 enum CallbackResult {
    589   CALLBACK_NO_SIGNATURE = 0,
    590   CALLBACK_INVALID_SIGNATURE,
    591   CALLBACK_VALID_SIGNATURE,
    592 
    593   // This is used in histograms - do not remove or reorder entries above! Also
    594   // the "MAX" item below should always be the last element.
    595 
    596   CALLBACK_RESULT_MAX
    597 };
    598 
    599 void GetSignatureResultHistogram(CallbackResult result) {
    600   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.GetSignatureResult",
    601                             result, CALLBACK_RESULT_MAX);
    602 }
    603 
    604 }  // namespace
    605 
    606 void InstallVerifier::SignatureCallback(
    607     scoped_ptr<InstallSignature> signature) {
    608 
    609   linked_ptr<PendingOperation> operation = operation_queue_.front();
    610   operation_queue_.pop();
    611 
    612   bool success = false;
    613   if (!signature.get()) {
    614     GetSignatureResultHistogram(CALLBACK_NO_SIGNATURE);
    615   } else if (!InstallSigner::VerifySignature(*signature)) {
    616     GetSignatureResultHistogram(CALLBACK_INVALID_SIGNATURE);
    617   } else {
    618     GetSignatureResultHistogram(CALLBACK_VALID_SIGNATURE);
    619     success = true;
    620   }
    621 
    622   if (!success) {
    623     OnVerificationComplete(false, operation->type);
    624 
    625     // TODO(asargent) - if this was something like a network error, we need to
    626     // do retries with exponential back off.
    627   } else {
    628     signature_ = signature.Pass();
    629     SaveToPrefs();
    630 
    631     if (!provisional_.empty()) {
    632       // Update |provisional_| to remove ids that were successfully signed.
    633       provisional_ = base::STLSetDifference<ExtensionIdSet>(
    634           provisional_, signature_->ids);
    635     }
    636 
    637     OnVerificationComplete(success, operation->type);
    638   }
    639 
    640   if (!operation_queue_.empty())
    641     BeginFetch();
    642 }
    643 
    644 }  // namespace extensions
    645