Cleanup: avoid foo ? true : false, part 1.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 2012 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 80 matching lines @@
     }
   }
   DCHECK(Extension::IdIsValid(id));
   return id;
 }
 
 // Returns given a crx id it returns a small number, less than 100, that has a
 // decent chance of being unique among the registered components. It also has
 // the nice property that can be trivially computed by hand.
 static int CrxIdtoUMAId(const std::string& id) {
-  CHECK(id.size() > 2);
+  CHECK_GT(id.size(), 2U);
   return id[0] + id[1] + id[2] - ('a' * 3);
 }
 
 // Helper to do version check for components.
 bool IsVersionNewer(const Version& current, const std::string& proposed) {
   Version proposed_ver(proposed);
   if (!proposed_ver.IsValid())
     return false;
   return (current.CompareTo(proposed_ver) < 0);
 }
@@ skipping 499 matching lines @@
   }
 }
 
 // A valid Omaha update check has arrived, from only the list of components that
 // we are currently upgrading we check for a match in which the server side
 // version is newer, if so we queue them for an upgrade. The next time we call
 // ProcessPendingItems() one of them will be drafted for the upgrade process.
 void CrxUpdateService::OnParseUpdateManifestSucceeded(
     const UpdateManifest::Results& results) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  int update_pending = 0;
+  size_t update_pending = 0;
   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.
 
     config_->OnEvent(Configurator::kManifestCheck, CrxIdtoUMAId(crx->id));
@@ skipping 26 matching lines @@
         chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND,
         content::Source<std::string>(&crx->id),
         content::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);
+  ScheduleNextRun(update_pending > 0);
 }
 
 void CrxUpdateService::OnParseUpdateManifestFailed(
     const std::string& error_message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   size_t count = ChangeItemStatus(CrxUpdateItem::kChecking,
                                   CrxUpdateItem::kNoUpdate);
   config_->OnEvent(Configurator::kManifestError, static_cast<int>(count));
   DCHECK_GT(count, 0ul);
   ScheduleNextRun(false);
@@ skipping 91 matching lines @@
   ScheduleNextRun(false);
 }
 
 // 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);
 }