Modified components ui to address concern of all the time disabled check update button.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright 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 <set>
 #include <vector>
 
@@ skipping 70 matching lines @@
 CrxUpdateItem::~CrxUpdateItem() {
 }
 
 CrxComponent::CrxComponent()
     : installer(NULL), allow_background_download(true) {
 }
 
 CrxComponent::~CrxComponent() {
 }
 
-CrxComponentInfo::CrxComponentInfo() {
-}
-
-CrxComponentInfo::~CrxComponentInfo() {
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // In charge of blocking url requests until the |crx_id| component has been
 // updated. This class is touched solely from the IO thread. The UI thread
 // can post tasks to it via weak pointers. By default the request is blocked
 // unless the CrxUpdateService calls Unblock().
 // The lifetime is controlled by Chrome's resource loader so the component
 // updater cannot touch objects from this class except via weak pointers.
 class CUResourceThrottle : public content::ResourceThrottle,
                            public base::SupportsWeakPtr<CUResourceThrottle> {
  public:
@@ skipping 47 matching lines @@
   explicit CrxUpdateService(ComponentUpdateService::Configurator* config);
   virtual ~CrxUpdateService();
 
   // Overrides for ComponentUpdateService.
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual Status Start() OVERRIDE;
   virtual Status Stop() OVERRIDE;
   virtual Status RegisterComponent(const CrxComponent& component) OVERRIDE;
   virtual Status OnDemandUpdate(const std::string& component_id) OVERRIDE;
-  virtual void GetComponents(
-      std::vector<CrxComponentInfo>* components) OVERRIDE;
+  virtual std::vector<std::string> GetComponentIDs() const OVERRIDE;
+  virtual CrxUpdateItem* GetComponentDetails(
+      const std::string& component_id) const OVERRIDE;
+
   virtual content::ResourceThrottle* GetOnDemandResourceThrottle(
       net::URLRequest* request,
       const std::string& crx_id) OVERRIDE;
 
   // Context for a crx download url request.
   struct CRXContext {
     ComponentInstaller* installer;
     std::vector<uint8> pk_hash;
     std::string id;
     std::string fingerprint;
@@ skipping 52 matching lines @@
                     int extended_error);
 
   void DoneInstalling(const std::string& component_id,
                       ComponentUnpacker::Error error,
                       int extended_error);
 
   void ChangeItemState(CrxUpdateItem* item, CrxUpdateItem::Status to);
 
   size_t ChangeItemStatus(CrxUpdateItem::Status from, CrxUpdateItem::Status to);
 
-  CrxUpdateItem* FindUpdateItemById(const std::string& id);
+  CrxUpdateItem* FindUpdateItemById(const std::string& id) const;
 
   void NotifyObservers(Observer::Events event, const std::string& id);
 
   bool HasOnDemandItems() const;
 
   void OnNewResourceThrottle(base::WeakPtr<CUResourceThrottle> rt,
                              const std::string& crx_id);
 
+  Status GetServiceStatus(const CrxUpdateItem::Status status);
+
   scoped_ptr<ComponentUpdateService::Configurator> config_;
 
   scoped_ptr<UpdateChecker> update_checker_;
 
   scoped_ptr<PingManager> ping_manager_;
 
   scoped_refptr<ComponentUnpacker> unpacker_;
 
   scoped_ptr<CrxDownloader> crx_downloader_;
 
@@ skipping 132 matching lines @@
   }
 
   VLOG(1) << "Scheduling next run to occur in " << delay_seconds << " seconds";
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromSeconds(delay_seconds),
                this,
                &CrxUpdateService::ProcessPendingItems);
 }
 
 // Given a extension-like component id, find the associated component.
-CrxUpdateItem* CrxUpdateService::FindUpdateItemById(const std::string& id) {
+CrxUpdateItem* CrxUpdateService::FindUpdateItemById(
+    const std::string& id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CrxUpdateItem::FindById finder(id);
-  UpdateItems::iterator it =
+  UpdateItems::const_iterator it =
       std::find_if(work_items_.begin(), work_items_.end(), finder);
   return it != work_items_.end() ? *it : NULL;
 }
 
 // Changes a component's status, clearing on_demand and firing notifications as
 // necessary. By convention, this is the only function that can change a
 // CrxUpdateItem's |status|.
 // TODO(waffles): Do we want to add DCHECKS for valid state transitions here?
 void CrxUpdateService::ChangeItemState(CrxUpdateItem* item,
                                        CrxUpdateItem::Status to) {
@@ skipping 94 matching lines @@
 ComponentUpdateService::Status CrxUpdateService::OnDemandUpdateInternal(
     CrxUpdateItem* uit) {
   if (!uit)
     return kError;
 
   // Check if the request is too soon.
   base::TimeDelta delta = base::Time::Now() - uit->last_check;
   if (delta < base::TimeDelta::FromSeconds(config_->OnDemandDelay()))
     return kError;
 
-  switch (uit->status) {
-    // If the item is already in the process of being updated, there is
-    // no point in this call, so return kInProgress.
-    case CrxUpdateItem::kChecking:
-    case CrxUpdateItem::kCanUpdate:
-    case CrxUpdateItem::kDownloadingDiff:
-    case CrxUpdateItem::kDownloading:
-    case CrxUpdateItem::kUpdatingDiff:
-    case CrxUpdateItem::kUpdating:
-      return kInProgress;
-    // Otherwise the item was already checked a while back (or it is new),
-    // set its status to kNew to give it a slightly higher priority.
-    case CrxUpdateItem::kNew:
-    case CrxUpdateItem::kUpdated:
-    case CrxUpdateItem::kUpToDate:
-    case CrxUpdateItem::kNoUpdate:
-      ChangeItemState(uit, CrxUpdateItem::kNew);
-      uit->on_demand = true;
-      break;
-    case CrxUpdateItem::kLastStatus:
-      NOTREACHED() << uit->status;
-  }
+  Status service_status = GetServiceStatus(uit->status);
+  // If the item is already in the process of being updated, there is
+  // no point in this call, so return kInProgress.
+  if (service_status == kInProgress)
+    return service_status;
+
+  // Otherwise the item was already checked a while back (or it is new),
+  // set its status to kNew to give it a slightly higher priority.
+  ChangeItemState(uit, CrxUpdateItem::kNew);
+  uit->on_demand = true;
 
   // In case the current delay is long, set the timer to a shorter value
   // to get the ball rolling.
   if (timer_.IsRunning()) {
     timer_.Stop();
     timer_.Start(FROM_HERE,
                  base::TimeDelta::FromSeconds(config_->StepDelay()),
                  this,
                  &CrxUpdateService::ProcessPendingItems);
   }
 
   return kOk;
 }
 
-void CrxUpdateService::GetComponents(
-    std::vector<CrxComponentInfo>* components) {
+std::vector<std::string> CrxUpdateService::GetComponentIDs() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::vector<std::string> component_ids;
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end();
        ++it) {
     const CrxUpdateItem* item = *it;
-    CrxComponentInfo info;
-    info.id = GetCrxComponentID(item->component);
-    info.version = item->component.version.GetString();
-    info.name = item->component.name;
-    components->push_back(info);
+    component_ids.push_back(item->id);
   }
+  return component_ids;
+}
+
+CrxUpdateItem* CrxUpdateService::GetComponentDetails(
+    const std::string& component_id) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return FindUpdateItemById(component_id);
 }
 
 // This is the main loop of the component updater. It updates one component
 // at a time if updates are available. Otherwise, it does an update check or
 // takes a long sleep until the loop runs again.
 void CrxUpdateService::ProcessPendingItems() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   CrxUpdateItem* ready_upgrade = FindReadyComponent();
   if (ready_upgrade) {
@@ skipping 427 matching lines @@
   // Check if we can on-demand update, else unblock the request anyway.
   CrxUpdateItem* item = FindUpdateItemById(crx_id);
   Status status = OnDemandUpdateInternal(item);
   if (status == kOk || status == kInProgress) {
     item->throttles.push_back(rt);
     return;
   }
   UnblockResourceThrottle(rt);
 }
 
+ComponentUpdateService::Status CrxUpdateService::GetServiceStatus(
+    CrxUpdateItem::Status status) {
+  switch (status) {
+    case CrxUpdateItem::kChecking:
+    case CrxUpdateItem::kCanUpdate:
+    case CrxUpdateItem::kDownloadingDiff:
+    case CrxUpdateItem::kDownloading:
+    case CrxUpdateItem::kUpdatingDiff:
+    case CrxUpdateItem::kUpdating:
+      return kInProgress;
+    case CrxUpdateItem::kNew:
+    case CrxUpdateItem::kUpdated:
+    case CrxUpdateItem::kUpToDate:
+    case CrxUpdateItem::kNoUpdate:
+      return kOk;
+      break;
+    case CrxUpdateItem::kLastStatus:
+      NOTREACHED() << status;
+  }
+  return kError;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CUResourceThrottle::CUResourceThrottle(const net::URLRequest* request)
     : state_(NEW) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 CUResourceThrottle::~CUResourceThrottle() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
@@ skipping 24 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);
 }
 
 }  // namespace component_updater