chrome/browser/extensions/updater/extension_updater.cc

   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/updater/extension_updater.h"
   6
   7 #include <algorithm>
   8 #include <set>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/logging.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/rand_util.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/string_split.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #include "chrome/browser/extensions/api/module/module.h"
  21 #include "chrome/browser/extensions/crx_installer.h"
  22 #include "chrome/browser/extensions/extension_service.h"
  23 #include "chrome/browser/extensions/pending_extension_manager.h"
  24 #include "chrome/browser/extensions/updater/extension_downloader.h"
  25 #include "chrome/browser/profiles/profile.h"
  26 #include "chrome/common/pref_names.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/browser/notification_details.h"
  29 #include "content/public/browser/notification_service.h"
  30 #include "content/public/browser/notification_source.h"
  31 #include "crypto/sha2.h"
  32 #include "extensions/browser/extension_prefs.h"
  33 #include "extensions/browser/extension_registry.h"
  34 #include "extensions/browser/pref_names.h"
  35 #include "extensions/common/constants.h"
  36 #include "extensions/common/extension.h"
  37 #include "extensions/common/extension_set.h"
  38 #include "extensions/common/manifest.h"
  39
  40 using base::RandDouble;
  41 using base::RandInt;
  42 using base::Time;
  43 using base::TimeDelta;
  44 using content::BrowserThread;
  45
  46 typedef extensions::ExtensionDownloaderDelegate::Error Error;
  47 typedef extensions::ExtensionDownloaderDelegate::PingResult PingResult;
  48
  49 namespace {
  50
  51 // Wait at least 5 minutes after browser startup before we do any checks. If you
  52 // change this value, make sure to update comments where it is used.
  53 const int kStartupWaitSeconds = 60 * 5;
  54
  55 // For sanity checking on update frequency - enforced in release mode only.
  56 #if defined(NDEBUG)
  57 const int kMinUpdateFrequencySeconds = 30;
  58 #endif
  59 const int kMaxUpdateFrequencySeconds = 60 * 60 * 24 * 7;  // 7 days
  60
  61 // Require at least 5 seconds between consecutive non-succesful extension update
  62 // checks.
  63 const int kMinUpdateThrottleTime = 5;
  64
  65 // When we've computed a days value, we want to make sure we don't send a
  66 // negative value (due to the system clock being set backwards, etc.), since -1
  67 // is a special sentinel value that means "never pinged", and other negative
  68 // values don't make sense.
  69 int SanitizeDays(int days) {
  70   if (days < 0)
  71     return 0;
  72   return days;
  73 }
  74
  75 // Calculates the value to use for the ping days parameter.
  76 int CalculatePingDays(const Time& last_ping_day) {
  77   int days = extensions::ManifestFetchData::kNeverPinged;
  78   if (!last_ping_day.is_null()) {
  79     days = SanitizeDays((Time::Now() - last_ping_day).InDays());
  80   }
  81   return days;
  82 }
  83
  84 int CalculateActivePingDays(const Time& last_active_ping_day,
  85                             bool hasActiveBit) {
  86   if (!hasActiveBit)
  87     return 0;
  88   if (last_active_ping_day.is_null())
  89     return extensions::ManifestFetchData::kNeverPinged;
  90   return SanitizeDays((Time::Now() - last_active_ping_day).InDays());
  91 }
  92
  93 }  // namespace
  94
  95 namespace extensions {
  96
  97 ExtensionUpdater::CheckParams::CheckParams()
  98     : install_immediately(false) {}
  99
 100 ExtensionUpdater::CheckParams::~CheckParams() {}
 101
 102 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile(
 103     const std::string& i,
 104     const base::FilePath& p,
 105     bool file_ownership_passed,
 106     const std::set<int>& request_ids)
 107     : extension_id(i),
 108       path(p),
 109       file_ownership_passed(file_ownership_passed),
 110       request_ids(request_ids) {}
 111
 112 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile()
 113     : path(), file_ownership_passed(true) {}
 114
 115 ExtensionUpdater::FetchedCRXFile::~FetchedCRXFile() {}
 116
 117 ExtensionUpdater::InProgressCheck::InProgressCheck()
 118     : install_immediately(false) {}
 119
 120 ExtensionUpdater::InProgressCheck::~InProgressCheck() {}
 121
 122 struct ExtensionUpdater::ThrottleInfo {
 123   ThrottleInfo()
 124       : in_progress(true),
 125         throttle_delay(kMinUpdateThrottleTime),
 126         check_start(Time::Now()) {}
 127
 128   bool in_progress;
 129   int throttle_delay;
 130   Time check_start;
 131 };
 132
 133 ExtensionUpdater::ExtensionUpdater(ExtensionServiceInterface* service,
 134                                    ExtensionPrefs* extension_prefs,
 135                                    PrefService* prefs,
 136                                    Profile* profile,
 137                                    int frequency_seconds,
 138                                    ExtensionCache* cache)
 139     : alive_(false),
 140       weak_ptr_factory_(this),
 141       service_(service), frequency_seconds_(frequency_seconds),
 142       will_check_soon_(false), extension_prefs_(extension_prefs),
 143       prefs_(prefs), profile_(profile),
 144       next_request_id_(0),
 145       crx_install_is_running_(false),
 146       extension_cache_(cache) {
 147   DCHECK_GE(frequency_seconds_, 5);
 148   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 149 #if defined(NDEBUG)
 150   // In Release mode we enforce that update checks don't happen too often.
 151   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 152 #endif
 153   frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
 154
 155   registrar_.Add(this,
 156                  chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
 157                  content::NotificationService::AllBrowserContextsAndSources());
 158 }
 159
 160 ExtensionUpdater::~ExtensionUpdater() {
 161   Stop();
 162 }
 163
 164 // The overall goal here is to balance keeping clients up to date while
 165 // avoiding a thundering herd against update servers.
 166 TimeDelta ExtensionUpdater::DetermineFirstCheckDelay() {
 167   DCHECK(alive_);
 168   // If someone's testing with a quick frequency, just allow it.
 169   if (frequency_seconds_ < kStartupWaitSeconds)
 170     return TimeDelta::FromSeconds(frequency_seconds_);
 171
 172   // If we've never scheduled a check before, start at frequency_seconds_.
 173   if (!prefs_->HasPrefPath(pref_names::kNextUpdateCheck))
 174     return TimeDelta::FromSeconds(frequency_seconds_);
 175
 176   // If it's been a long time since our last actual check, we want to do one
 177   // relatively soon.
 178   Time now = Time::Now();
 179   Time last = Time::FromInternalValue(prefs_->GetInt64(
 180       pref_names::kLastUpdateCheck));
 181   int days = (now - last).InDays();
 182   if (days >= 30) {
 183     // Wait 5-10 minutes.
 184     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
 185                                           kStartupWaitSeconds * 2));
 186   } else if (days >= 14) {
 187     // Wait 10-20 minutes.
 188     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 2,
 189                                           kStartupWaitSeconds * 4));
 190   } else if (days >= 3) {
 191     // Wait 20-40 minutes.
 192     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 4,
 193                                           kStartupWaitSeconds * 8));
 194   }
 195
 196   // Read the persisted next check time, and use that if it isn't too soon
 197   // or too late. Otherwise pick something random.
 198   Time saved_next = Time::FromInternalValue(prefs_->GetInt64(
 199       pref_names::kNextUpdateCheck));
 200   Time earliest = now + TimeDelta::FromSeconds(kStartupWaitSeconds);
 201   Time latest = now + TimeDelta::FromSeconds(frequency_seconds_);
 202   if (saved_next >= earliest && saved_next <= latest) {
 203     return saved_next - now;
 204   } else {
 205     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
 206                                           frequency_seconds_));
 207   }
 208 }
 209
 210 void ExtensionUpdater::Start() {
 211   DCHECK(!alive_);
 212   // If these are NULL, then that means we've been called after Stop()
 213   // has been called.
 214   DCHECK(service_);
 215   DCHECK(extension_prefs_);
 216   DCHECK(prefs_);
 217   DCHECK(profile_);
 218   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
 219   alive_ = true;
 220   // Make sure our prefs are registered, then schedule the first check.
 221   ScheduleNextCheck(DetermineFirstCheckDelay());
 222 }
 223
 224 void ExtensionUpdater::Stop() {
 225   weak_ptr_factory_.InvalidateWeakPtrs();
 226   alive_ = false;
 227   service_ = NULL;
 228   extension_prefs_ = NULL;
 229   prefs_ = NULL;
 230   profile_ = NULL;
 231   timer_.Stop();
 232   will_check_soon_ = false;
 233   downloader_.reset();
 234 }
 235
 236 void ExtensionUpdater::ScheduleNextCheck(const TimeDelta& target_delay) {
 237   DCHECK(alive_);
 238   DCHECK(!timer_.IsRunning());
 239   DCHECK(target_delay >= TimeDelta::FromSeconds(1));
 240
 241   // Add +/- 10% random jitter.
 242   double delay_ms = target_delay.InMillisecondsF();
 243   double jitter_factor = (RandDouble() * .2) - 0.1;
 244   delay_ms += delay_ms * jitter_factor;
 245   TimeDelta actual_delay = TimeDelta::FromMilliseconds(
 246       static_cast<int64>(delay_ms));
 247
 248   // Save the time of next check.
 249   Time next = Time::Now() + actual_delay;
 250   prefs_->SetInt64(pref_names::kNextUpdateCheck, next.ToInternalValue());
 251
 252   timer_.Start(FROM_HERE, actual_delay, this, &ExtensionUpdater::TimerFired);
 253 }
 254
 255 void ExtensionUpdater::TimerFired() {
 256   DCHECK(alive_);
 257   CheckNow(default_params_);
 258
 259   // If the user has overridden the update frequency, don't bother reporting
 260   // this.
 261   if (frequency_seconds_ == extensions::kDefaultUpdateFrequencySeconds) {
 262     Time last = Time::FromInternalValue(prefs_->GetInt64(
 263         pref_names::kLastUpdateCheck));
 264     if (last.ToInternalValue() != 0) {
 265       // Use counts rather than time so we can use minutes rather than millis.
 266       UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.UpdateCheckGap",
 267           (Time::Now() - last).InMinutes(),
 268           TimeDelta::FromSeconds(kStartupWaitSeconds).InMinutes(),
 269           TimeDelta::FromDays(40).InMinutes(),
 270           50);  // 50 buckets seems to be the default.
 271     }
 272   }
 273
 274   // Save the last check time, and schedule the next check.
 275   int64 now = Time::Now().ToInternalValue();
 276   prefs_->SetInt64(pref_names::kLastUpdateCheck, now);
 277   ScheduleNextCheck(TimeDelta::FromSeconds(frequency_seconds_));
 278 }
 279
 280 void ExtensionUpdater::CheckSoon() {
 281   DCHECK(alive_);
 282   if (will_check_soon_)
 283     return;
 284   if (BrowserThread::PostTask(
 285           BrowserThread::UI, FROM_HERE,
 286           base::Bind(&ExtensionUpdater::DoCheckSoon,
 287                      weak_ptr_factory_.GetWeakPtr()))) {
 288     will_check_soon_ = true;
 289   } else {
 290     NOTREACHED();
 291   }
 292 }
 293
 294 bool ExtensionUpdater::WillCheckSoon() const {
 295   return will_check_soon_;
 296 }
 297
 298 void ExtensionUpdater::DoCheckSoon() {
 299   DCHECK(will_check_soon_);
 300   CheckNow(default_params_);
 301   will_check_soon_ = false;
 302 }
 303
 304 void ExtensionUpdater::AddToDownloader(
 305     const ExtensionSet* extensions,
 306     const std::list<std::string>& pending_ids,
 307     int request_id) {
 308   InProgressCheck& request = requests_in_progress_[request_id];
 309   for (ExtensionSet::const_iterator extension_iter = extensions->begin();
 310        extension_iter != extensions->end(); ++extension_iter) {
 311     const Extension& extension = *extension_iter->get();
 312     if (!Manifest::IsAutoUpdateableLocation(extension.location())) {
 313       VLOG(2) << "Extension " << extension.id() << " is not auto updateable";
 314       continue;
 315     }
 316     // An extension might be overwritten by policy, and have its update url
 317     // changed. Make sure existing extensions aren't fetched again, if a
 318     // pending fetch for an extension with the same id already exists.
 319     std::list<std::string>::const_iterator pending_id_iter = std::find(
 320         pending_ids.begin(), pending_ids.end(), extension.id());
 321     if (pending_id_iter == pending_ids.end()) {
 322       if (downloader_->AddExtension(extension, request_id))
 323         request.in_progress_ids_.push_back(extension.id());
 324     }
 325   }
 326 }
 327
 328 void ExtensionUpdater::CheckNow(const CheckParams& params) {
 329   int request_id = next_request_id_++;
 330
 331   VLOG(2) << "Starting update check " << request_id;
 332   if (params.ids.empty())
 333     NotifyStarted();
 334
 335   DCHECK(alive_);
 336
 337   InProgressCheck& request = requests_in_progress_[request_id];
 338   request.callback = params.callback;
 339   request.install_immediately = params.install_immediately;
 340
 341   if (!downloader_.get()) {
 342     downloader_.reset(
 343         new ExtensionDownloader(this, profile_->GetRequestContext()));
 344   }
 345
 346   // Add fetch records for extensions that should be fetched by an update URL.
 347   // These extensions are not yet installed. They come from group policy
 348   // and external install sources.
 349   const PendingExtensionManager* pending_extension_manager =
 350       service_->pending_extension_manager();
 351
 352   std::list<std::string> pending_ids;
 353
 354   if (params.ids.empty()) {
 355     // If no extension ids are specified, check for updates for all extensions.
 356     pending_extension_manager->GetPendingIdsForUpdateCheck(&pending_ids);
 357
 358     std::list<std::string>::const_iterator iter;
 359     for (iter = pending_ids.begin(); iter != pending_ids.end(); ++iter) {
 360       const PendingExtensionInfo* info = pending_extension_manager->GetById(
 361           *iter);
 362       if (!Manifest::IsAutoUpdateableLocation(info->install_source())) {
 363         VLOG(2) << "Extension " << *iter << " is not auto updateable";
 364         continue;
 365       }
 366       if (downloader_->AddPendingExtension(*iter, info->update_url(),
 367                                            request_id))
 368         request.in_progress_ids_.push_back(*iter);
 369     }
 370
 371     ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
 372     AddToDownloader(&registry->enabled_extensions(), pending_ids, request_id);
 373     AddToDownloader(&registry->disabled_extensions(), pending_ids, request_id);
 374   } else {
 375     for (std::list<std::string>::const_iterator it = params.ids.begin();
 376          it != params.ids.end(); ++it) {
 377       const Extension* extension = service_->GetExtensionById(*it, true);
 378       DCHECK(extension);
 379       if (downloader_->AddExtension(*extension, request_id))
 380         request.in_progress_ids_.push_back(extension->id());
 381     }
 382   }
 383
 384   // StartAllPending() might call OnExtensionDownloadFailed/Finished before
 385   // it returns, which would cause NotifyIfFinished to incorrectly try to
 386   // send out a notification. So check before we call StartAllPending if any
 387   // extensions are going to be updated, and use that to figure out if
 388   // NotifyIfFinished should be called.
 389   bool noChecks = request.in_progress_ids_.empty();
 390
 391   // StartAllPending() will call OnExtensionDownloadFailed or
 392   // OnExtensionDownloadFinished for each extension that was checked.
 393   downloader_->StartAllPending(extension_cache_);
 394
 395   if (noChecks)
 396     NotifyIfFinished(request_id);
 397 }
 398
 399 bool ExtensionUpdater::CheckExtensionSoon(const std::string& extension_id,
 400                                           const FinishedCallback& callback) {
 401   bool have_throttle_info = ContainsKey(throttle_info_, extension_id);
 402   ThrottleInfo& info = throttle_info_[extension_id];
 403   if (have_throttle_info) {
 404     // We already had a ThrottleInfo object for this extension, check if the
 405     // update check request should be allowed.
 406
 407     // If another check is in progress, don't start a new check.
 408     if (info.in_progress)
 409       return false;
 410
 411     Time now = Time::Now();
 412     Time last = info.check_start;
 413     // If somehow time moved back, we don't want to infinitely keep throttling.
 414     if (now < last) {
 415       last = now;
 416       info.check_start = now;
 417     }
 418     Time earliest = last + TimeDelta::FromSeconds(info.throttle_delay);
 419     // If check is too soon, throttle.
 420     if (now < earliest)
 421       return false;
 422
 423     // TODO(mek): Somehow increase time between allowing checks when checks
 424     // are repeatedly throttled and don't result in updates being installed.
 425
 426     // It's okay to start a check, update values.
 427     info.check_start = now;
 428     info.in_progress = true;
 429   }
 430
 431   CheckParams params;
 432   params.ids.push_back(extension_id);
 433   params.callback = base::Bind(&ExtensionUpdater::ExtensionCheckFinished,
 434                                weak_ptr_factory_.GetWeakPtr(),
 435                                extension_id, callback);
 436   CheckNow(params);
 437   return true;
 438 }
 439
 440 void ExtensionUpdater::ExtensionCheckFinished(
 441     const std::string& extension_id,
 442     const FinishedCallback& callback) {
 443   std::map<std::string, ThrottleInfo>::iterator it =
 444       throttle_info_.find(extension_id);
 445   if (it != throttle_info_.end()) {
 446     it->second.in_progress = false;
 447   }
 448   callback.Run();
 449 }
 450
 451 void ExtensionUpdater::OnExtensionDownloadFailed(
 452     const std::string& id,
 453     Error error,
 454     const PingResult& ping,
 455     const std::set<int>& request_ids) {
 456   DCHECK(alive_);
 457   UpdatePingData(id, ping);
 458   bool install_immediately = false;
 459   for (std::set<int>::const_iterator it = request_ids.begin();
 460        it != request_ids.end(); ++it) {
 461     InProgressCheck& request = requests_in_progress_[*it];
 462     install_immediately |= request.install_immediately;
 463     request.in_progress_ids_.remove(id);
 464     NotifyIfFinished(*it);
 465   }
 466
 467   // This method is called if no updates were found. However a previous update
 468   // check might have queued an update for this extension already. If a
 469   // current update check has |install_immediately| set the previously
 470   // queued update should be installed now.
 471   if (install_immediately && service_->GetPendingExtensionUpdate(id))
 472     service_->FinishDelayedInstallation(id);
 473 }
 474
 475 void ExtensionUpdater::OnExtensionDownloadFinished(
 476     const std::string& id,
 477     const base::FilePath& path,
 478     bool file_ownership_passed,
 479     const GURL& download_url,
 480     const std::string& version,
 481     const PingResult& ping,
 482     const std::set<int>& request_ids) {
 483   DCHECK(alive_);
 484   UpdatePingData(id, ping);
 485
 486   VLOG(2) << download_url << " written to " << path.value();
 487
 488   FetchedCRXFile fetched(id, path, file_ownership_passed, request_ids);
 489   fetched_crx_files_.push(fetched);
 490
 491   // MaybeInstallCRXFile() removes extensions from |in_progress_ids_| after
 492   // starting the crx installer.
 493   MaybeInstallCRXFile();
 494 }
 495
 496 bool ExtensionUpdater::GetPingDataForExtension(
 497     const std::string& id,
 498     ManifestFetchData::PingData* ping_data) {
 499   DCHECK(alive_);
 500   ping_data->rollcall_days = CalculatePingDays(
 501       extension_prefs_->LastPingDay(id));
 502   ping_data->is_enabled = service_->IsExtensionEnabled(id);
 503   ping_data->active_days =
 504       CalculateActivePingDays(extension_prefs_->LastActivePingDay(id),
 505                               extension_prefs_->GetActiveBit(id));
 506   return true;
 507 }
 508
 509 std::string ExtensionUpdater::GetUpdateUrlData(const std::string& id) {
 510   DCHECK(alive_);
 511   return extension::GetUpdateURLData(extension_prefs_, id);
 512 }
 513
 514 bool ExtensionUpdater::IsExtensionPending(const std::string& id) {
 515   DCHECK(alive_);
 516   return service_->pending_extension_manager()->IsIdPending(id);
 517 }
 518
 519 bool ExtensionUpdater::GetExtensionExistingVersion(const std::string& id,
 520                                                    std::string* version) {
 521   DCHECK(alive_);
 522   const Extension* extension = service_->GetExtensionById(id, true);
 523   if (!extension)
 524     return false;
 525   const Extension* update = service_->GetPendingExtensionUpdate(id);
 526   if (update)
 527     *version = update->VersionString();
 528   else
 529     *version = extension->VersionString();
 530   return true;
 531 }
 532
 533 void ExtensionUpdater::UpdatePingData(const std::string& id,
 534                                       const PingResult& ping_result) {
 535   DCHECK(alive_);
 536   if (ping_result.did_ping)
 537     extension_prefs_->SetLastPingDay(id, ping_result.day_start);
 538   if (extension_prefs_->GetActiveBit(id)) {
 539     extension_prefs_->SetActiveBit(id, false);
 540     extension_prefs_->SetLastActivePingDay(id, ping_result.day_start);
 541   }
 542 }
 543
 544 void ExtensionUpdater::MaybeInstallCRXFile() {
 545   if (crx_install_is_running_ || fetched_crx_files_.empty())
 546     return;
 547
 548   std::set<int> request_ids;
 549
 550   while (!fetched_crx_files_.empty() && !crx_install_is_running_) {
 551     const FetchedCRXFile& crx_file = fetched_crx_files_.top();
 552
 553     VLOG(2) << "updating " << crx_file.extension_id
 554             << " with " << crx_file.path.value();
 555
 556     // The ExtensionService is now responsible for cleaning up the temp file
 557     // at |crx_file.path|.
 558     CrxInstaller* installer = NULL;
 559     if (service_->UpdateExtension(crx_file.extension_id,
 560                                   crx_file.path,
 561                                   crx_file.file_ownership_passed,
 562                                   &installer)) {
 563       crx_install_is_running_ = true;
 564       current_crx_file_ = crx_file;
 565
 566       for (std::set<int>::const_iterator it = crx_file.request_ids.begin();
 567           it != crx_file.request_ids.end(); ++it) {
 568         InProgressCheck& request = requests_in_progress_[*it];
 569         if (request.install_immediately) {
 570           installer->set_install_wait_for_idle(false);
 571           break;
 572         }
 573       }
 574
 575       // Source parameter ensures that we only see the completion event for the
 576       // the installer we started.
 577       registrar_.Add(this,
 578                      chrome::NOTIFICATION_CRX_INSTALLER_DONE,
 579                      content::Source<CrxInstaller>(installer));
 580     } else {
 581       for (std::set<int>::const_iterator it = crx_file.request_ids.begin();
 582            it != crx_file.request_ids.end(); ++it) {
 583         InProgressCheck& request = requests_in_progress_[*it];
 584         request.in_progress_ids_.remove(crx_file.extension_id);
 585       }
 586       request_ids.insert(crx_file.request_ids.begin(),
 587                          crx_file.request_ids.end());
 588     }
 589     fetched_crx_files_.pop();
 590   }
 591
 592   for (std::set<int>::const_iterator it = request_ids.begin();
 593        it != request_ids.end(); ++it) {
 594     NotifyIfFinished(*it);
 595   }
 596 }
 597
 598 void ExtensionUpdater::Observe(int type,
 599                                const content::NotificationSource& source,
 600                                const content::NotificationDetails& details) {
 601   switch (type) {
 602     case chrome::NOTIFICATION_CRX_INSTALLER_DONE: {
 603       // No need to listen for CRX_INSTALLER_DONE anymore.
 604       registrar_.Remove(this,
 605                         chrome::NOTIFICATION_CRX_INSTALLER_DONE,
 606                         source);
 607       crx_install_is_running_ = false;
 608
 609       const FetchedCRXFile& crx_file = current_crx_file_;
 610       for (std::set<int>::const_iterator it = crx_file.request_ids.begin();
 611           it != crx_file.request_ids.end(); ++it) {
 612         InProgressCheck& request = requests_in_progress_[*it];
 613         request.in_progress_ids_.remove(crx_file.extension_id);
 614         NotifyIfFinished(*it);
 615       }
 616
 617       // If any files are available to update, start one.
 618       MaybeInstallCRXFile();
 619       break;
 620     }
 621     case chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED: {
 622       const Extension* extension =
 623           content::Details<const InstalledExtensionInfo>(details)->extension;
 624       if (extension)
 625         throttle_info_.erase(extension->id());
 626       break;
 627     }
 628     default:
 629       NOTREACHED();
 630   }
 631 }
 632
 633 void ExtensionUpdater::NotifyStarted() {
 634   content::NotificationService::current()->Notify(
 635       chrome::NOTIFICATION_EXTENSION_UPDATING_STARTED,
 636       content::Source<Profile>(profile_),
 637       content::NotificationService::NoDetails());
 638 }
 639
 640 void ExtensionUpdater::NotifyIfFinished(int request_id) {
 641   DCHECK(ContainsKey(requests_in_progress_, request_id));
 642   const InProgressCheck& request = requests_in_progress_[request_id];
 643   if (request.in_progress_ids_.empty()) {
 644     VLOG(2) << "Finished update check " << request_id;
 645     if (!request.callback.is_null())
 646       request.callback.Run();
 647     requests_in_progress_.erase(request_id);
 648   }
 649 }
 650
 651 }  // namespace extensions