Component updater on-demand logic with ResourceThrottle

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 <set>
 #include <vector>
 
@@ skipping 22 matching lines @@
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
+#include "content/public/browser/resource_throttle.h"
+#include "content/public/browser/resource_controller.h"
+#include "net/url_request/url_request.h"
+
 using content::BrowserThread;
 using content::UtilityProcessHost;
 using content::UtilityProcessHostClient;
 using extensions::Extension;
 
 // The component updater is designed to live until process shutdown, so
 // base::Bind() calls are not refcounted.
 
 namespace {
 
@@ skipping 175 matching lines @@
   return HexStringToID(StringToLowerASCII(base::HexEncode(&component.pk_hash[0],
                                           component.pk_hash.size()/2)));
 }
 
 CrxComponentInfo::CrxComponentInfo() {
 }
 
 CrxComponentInfo::~CrxComponentInfo() {
 }
 
+////////////////////////////////////////////////////////////////////////////////
+class CUResourceThrottle
+    : public content::ResourceThrottle {
+ public:
+  explicit CUResourceThrottle(const net::URLRequest* request);
+  virtual ~CUResourceThrottle();
+  virtual void WillStartRequest(bool* defer) OVERRIDE;
+  virtual void WillRedirectRequest(const GURL& new_url, bool* defer) OVERRIDE;
+  void Unblock();
+};
+
 //////////////////////////////////////////////////////////////////////////////
 // The one and only implementation of the ComponentUpdateService interface. In
 // charge of running the show. The main method is ProcessPendingItems() which
 // is called periodically to do the upgrades/installs or the update checks.
 // An important consideration here is to be as "low impact" as we can to the
 // rest of the browser, so even if we have many components registered and
 // eligible for update, we only do one thing at a time with pauses in between
 // the tasks. Also when we do network requests there is only one |url_fetcher_|
 // in flight at a time.
 // There are no locks in this code, the main structure |work_items_| is mutated
 // only from the UI thread. The unpack and installation is done in the file
 // thread and the network requests are done in the IO thread and in the file
 // thread.
 class CrxUpdateService : public ComponentUpdateService {
  public:
   explicit CrxUpdateService(ComponentUpdateService::Configurator* config);
 
   virtual ~CrxUpdateService();
 
   // Overrides for ComponentUpdateService.
   virtual Status Start() OVERRIDE;
   virtual Status Stop() OVERRIDE;
   virtual Status RegisterComponent(const CrxComponent& component) OVERRIDE;
   virtual Status CheckForUpdateSoon(const std::string& component_id) OVERRIDE;
   virtual void GetComponents(
       std::vector<CrxComponentInfo>* components) OVERRIDE;
+  virtual content::ResourceThrottle* GetResourceThrottle(
+      net::URLRequest* request, const char* crx_id) OVERRIDE;
 
   // The only purpose of this class is to forward the
   // UtilityProcessHostClient callbacks so CrxUpdateService does
   // not have to derive from it because that is refcounted.
   class ManifestParserBridge : public UtilityProcessHostClient {
    public:
     explicit ManifestParserBridge(CrxUpdateService* service)
         : service_(service) {}
 
     virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
@@ skipping 80 matching lines @@
                       int extended_error);
 
   size_t ChangeItemStatus(CrxUpdateItem::Status from,
                           CrxUpdateItem::Status to);
 
   CrxUpdateItem* FindUpdateItemById(const std::string& id);
 
   void NotifyComponentObservers(ComponentObserver::Events event,
                                 int extra) const;
 
+  void OnDemandUpdate(CUResourceThrottle* rt, const char* crx_id);
+
   scoped_ptr<ComponentUpdateService::Configurator> config_;
 
   scoped_ptr<ComponentPatcher> component_patcher_;
 
   scoped_ptr<net::URLFetcher> url_fetcher_;
 
   scoped_ptr<component_updater::PingManager> ping_manager_;
 
   // A collection of every work item.
   typedef std::vector<CrxUpdateItem*> UpdateItems;
@@ skipping 621 matching lines @@
 void CrxUpdateService::NotifyComponentObservers(
     ComponentObserver::Events event, int extra) const {
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end(); ++it) {
     ComponentObserver* observer = (*it)->component.observer;
     if (observer)
       observer->OnEvent(event, 0);
   }
 }
 
+content::ResourceThrottle* CrxUpdateService::GetResourceThrottle(
+    net::URLRequest* request, const char* crx_id) {
+  // careful, we might create more than one resource throttle for the same
+  // crx_id, so there needs to be logic that manages that.
+  CUResourceThrottle* rt = new CUResourceThrottle(request);
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&CrxUpdateService::OnDemandUpdate, base::Unretained(this),
+                 rt, crx_id));
+
+  return rt;
+}
+
+void CrxUpdateService::OnDemandUpdate(
+    CUResourceThrottle* rt, const char* crx_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  CrxUpdateItem* item = FindUpdateItemById(crx_id);
+  if (!item) {
+    rt->Unblock();
+    return;
+  }
+  // Then
+  // 1) check that we are not updating this component already.
+  // 2) Call something like
+  //   item.component.installer->OnDemandUpdate(..)  first?

[jvoung (off chromium), 2013/10/09 17:05:22]

What do you imagine 2) is used for?

We also need some signal when things are "done" (either successfully or with an
error).

Downstream, for PNacl, there's two async events that we need to wait for
"completion":

(a) Start pexe fetch
(b) Start loading component files

We need to wait until (a) has at least started and (b) is totally ready.

For (a) we need the response headers at least to check for LastModified, Etags,
etc. for translation caching, and for (b) we need to know when it's okay start
the translator process and start streaming the bytes over to that process for
streaming translation.

+  // 3) add it to the 'update_now' list. etc
+  //
+  // If things go sour you can call from the throttle
+  // controller()->Cancel().
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CUResourceThrottle::CUResourceThrottle(
+    const net::URLRequest* request) {
+    // Called from the IO thread.
+}
+
+CUResourceThrottle::~CUResourceThrottle() {
+  // Not sure about the lifetime
+  // delete this; is a possiblity.
+}
+
+void CUResourceThrottle::WillStartRequest(bool* defer) {
+  // By definition we need to block the resource until CUS calls back, typically
+  // expecting UnBlock() once the component is installed.
+  *defer = true;
+}
+
+void CUResourceThrottle::WillRedirectRequest(const GURL& new_url, bool* defer) {
+  *defer = false;

[darin (slow to review), 2013/10/03 21:31:43]

note: you could have a redirect to a media type that you wish to defer. the
ResourceThrottle is permitted to store the URLRequest that it is given in its
constructor. That pointer will remain valid for the lifetime of the
ResourceThrottle. You can then inspect the URLRequest to learn what the response
meta data looks like.

+}
+
+void CUResourceThrottle::Unblock() {
+  // Can this be called from the UI thread?
+  controller()->Resume();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // 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);
 }