src/chrome/browser/extensions/install_verifier.cc

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