Component updater eight piece

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 326 matching lines @@
   running_ = false;
   timer_.Stop();
   return kOk;
 }
 
 // This function sets the timer which will call ProcessPendingItems() there
 // are two kind of waits, the short one (with step_delay = true) and the
 // long one.
 void CrxUpdateService::ScheduleNextRun(bool step_delay) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(url_fetcher_.get() == NULL);
   CHECK(!timer_.IsRunning());
   // It could be the case that Stop() had been called while a url request
   // or unpacking was in flight, if so we arrive here but |running_| is
   // false. In that case do not loop again.
   if (!running_)
     return;
 
+  int64 delay = step_delay ? config_->StepDelay() : config_->NextCheckDelay();
+
   if (!step_delay) {
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING,
         Source<ComponentUpdateService>(this),
         NotificationService::NoDetails());
     // Zero is only used for unit tests.
-    if (0 == config_->NextCheckDelay())
+    if (0 == delay)
       return;
   }
 
-  int64 delay = step_delay ? config_->StepDelay() : config_->NextCheckDelay();
   timer_.Start(base::TimeDelta::FromSeconds(delay),
                this, &CrxUpdateService::ProcessPendingItems);
 }
 
 // Given a extension-like component id, find the associated component.
 CrxUpdateItem* CrxUpdateService::FindUpdateItemById(const std::string& id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CrxUpdateItem::FindById finder(id);
   UpdateItems::iterator it = std::find_if(work_items_.begin(),
                                           work_items_.end(),
@@ skipping 107 matching lines @@
 
   // Next we can go back to components we already checked, here
   // we can also batch them in a single url request, as long as
   // we have not checked them recently.
   base::TimeDelta min_delta_time =
       base::TimeDelta::FromSeconds(config_->MinimumReCheckWait());
 
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end(); ++it) {
     CrxUpdateItem* item = *it;
-    if ((item->status != CrxUpdateItem::kNoUpdate) ||
+    if ((item->status != CrxUpdateItem::kNoUpdate) &&
         (item->status != CrxUpdateItem::kUpToDate))
       continue;
     base::TimeDelta delta = base::Time::Now() - item->last_check;
     if (delta < min_delta_time)
       continue;
     if (!AddItemToUpdateCheck(item, &query))
       break;
   }
   // Finally, we check components that we already updated.
   for (UpdateItems::const_iterator it = work_items_.begin();
@@ skipping 22 matching lines @@
 }
 
 // Caled when we got a response from the update server. It consists of an xml
 // document following the omaha update scheme.
 void CrxUpdateService::OnURLFetchComplete(const URLFetcher* source,
                                           UpdateContext*) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (FetchSuccess(*source)) {
     std::string xml;
     source->GetResponseAsString(&xml);
+    url_fetcher_.reset();

[asargent_no_longer_on_chrome, 2011/08/09 17:56:19]

Not a big deal, but it looks a little weird to reset the fetcher in either case
here. Would it read better as the following?

bool success = FetchSuccess(*source);
url_fetcher_.reset();
if (success) {
  ...
} else {
  ...
}

[cpu_(ooo_6.6-7.5), 2011/08/09 20:21:53]

I would like to do that but then
 I can't do source->GetResponseAsString(..)

On 2011/08/09 17:56:19, Antony Sargent wrote:

     ParseManifest(xml);
   } else {
+    url_fetcher_.reset();
     CrxUpdateService::OnParseUpdateManifestFailed("network error");
   }
-  url_fetcher_.reset();
 }
 
 // Parsing the manifest is either done right now for tests or in a sandboxed
 // process for the production environment. This mitigates the case where an
 // attacker was able to feed us a malicious xml string.
 void CrxUpdateService::ParseManifest(const std::string& xml) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (config_->InProcess()) {
     UpdateManifest manifest;
     if (!manifest.Parse(xml)) {
@@ skipping 20 matching lines @@
   std::vector<UpdateManifest::Result>::const_iterator it;
   for (it = results.list.begin(); it != results.list.end(); ++it) {
     CrxUpdateItem* crx = FindUpdateItemById(it->extension_id);
     if (!crx)
       continue;
 
     if (crx->status != CrxUpdateItem::kChecking)
       continue;  // Not updating this component now.
 
     if (it->version.empty()) {
+      // No version means no update available.
       crx->status = CrxUpdateItem::kNoUpdate;
-      continue;  // No version means no update available.
+      continue;
     }
     if (!IsVersionNewer(crx->component.version, it->version)) {
+      // Our component is up to date.
       crx->status = CrxUpdateItem::kUpToDate;
-      continue;  // Our component is up to date.
+      continue;
     }
     if (!it->browser_min_version.empty()) {
-      if (IsVersionNewer(chrome_version_, it->browser_min_version))
-        continue;  // Does not apply for this version.
+      if (IsVersionNewer(chrome_version_, it->browser_min_version)) {
+        // Does not apply for this chrome version.
+        crx->status = CrxUpdateItem::kNoUpdate;
+        continue;
+      }
     }
     // All test passed. Queue an upgrade for this component and fire the
     // notifications.
     crx->crx_url = it->crx_url;
     crx->status = CrxUpdateItem::kCanUpdate;
     ++update_pending;
 
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND,
         Source<std::string>(&crx->id),
         NotificationService::NoDetails());
   }
+
+  // All the components that are not mentioned in the manifest we
+  // consider them up to date.
+  ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kUpToDate);
+
   // If there are updates pending we do a short wait.
   ScheduleNextRun(update_pending ? true : false);
 }
 
 void CrxUpdateService::OnParseUpdateManifestFailed(
     const std::string& error_message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   size_t count = ChangeItemStatus(CrxUpdateItem::kChecking,
                                   CrxUpdateItem::kNoUpdate);
   DCHECK_GT(count, 0ul);
   ScheduleNextRun(false);
 }
 
 // Called when the CRX package has been downloaded to a temporary location.
 // Here we fire the notifications and schedule the component-specific installer
 // to be called in the file thread.
 void CrxUpdateService::OnURLFetchComplete(const URLFetcher* source,
                                           CRXContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::PlatformFileError error_code;
 
   if (source->FileErrorOccurred(&error_code) || !FetchSuccess(*source)) {
     size_t count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                     CrxUpdateItem::kNoUpdate);
     DCHECK_EQ(count, 1ul);
+    url_fetcher_.reset();
     ScheduleNextRun(false);
   } else {
     FilePath temp_crx_path;
     CHECK(source->GetResponseAsFilePath(true, &temp_crx_path));
     size_t count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                     CrxUpdateItem::kUpdating);
     DCHECK_EQ(count, 1ul);
+    url_fetcher_.reset();
+
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_READY,
         Source<std::string>(&context->id),
         NotificationService::NoDetails());
 
     BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &CrxUpdateService::Install,
                           context,
                           temp_crx_path),
         config_->StepDelay());
   }
-
-  url_fetcher_.reset();
 }
 
 // Install consists of digital signature verification, unpacking and then
 // calling the component specific installer. All that is handled by the
 // |unpacker|. If there is an error this function is in charge of deleting
 // the files created.
 void CrxUpdateService::Install(const CRXContext* context,
                                const FilePath& crx_path) {
   // This function owns the |crx_path| and the |context| object.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 23 matching lines @@
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }