Support asynchronous patching operations in the component updater.

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>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_patcher.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
 #include "chrome/browser/component_updater/component_updater_ping_manager.h"
 #include "chrome/browser/component_updater/component_updater_utils.h"
 #include "chrome/browser/component_updater/crx_downloader.h"
 #include "chrome/browser/component_updater/crx_update_item.h"
@@ skipping 188 matching lines @@
   bool CheckForUpdates();
 
   void UpdateComponent(CrxUpdateItem* workitem);
 
   void ScheduleNextRun(StepDelayInterval step_delay);
 
   void ParseResponse(const std::string& xml);
 
   void Install(scoped_ptr<CRXContext> context, const base::FilePath& crx_path);
 
+  void DoneUnpacking(const std::string& component_id,
+                     const base::FilePath& crx_path,
+                     ComponentUnpacker::Error error,
+                     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);
 
   void NotifyComponentObservers(ComponentObserver::Events event,
                                 int extra) const;
 
   bool HasOnDemandItems() const;
 
   void OnNewResourceThrottle(base::WeakPtr<CUResourceThrottle> rt,
                              const std::string& crx_id);
 
   scoped_ptr<ComponentUpdateService::Configurator> config_;
 
   scoped_ptr<ComponentPatcher> component_patcher_;
 
   scoped_ptr<UpdateChecker> update_checker_;
 
   scoped_ptr<PingManager> ping_manager_;
 
+  scoped_ptr<ComponentUnpacker> unpacker_;
+
   scoped_ptr<CrxDownloader> crx_downloader_;
 
   // A collection of every work item.
   typedef std::vector<CrxUpdateItem*> UpdateItems;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
@@ skipping 556 matching lines @@
         base::Bind(&CrxUpdateService::Install,
                    base::Unretained(this),
                    base::Passed(&crx_context),
                    download_result.response),
         base::TimeDelta::FromMilliseconds(config_->StepDelay()));
   }
 }
 
 // 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
+// |unpacker_|. If there is an error this function is in charge of deleting
 // the files created.
 void CrxUpdateService::Install(scoped_ptr<CRXContext> context,
                                const base::FilePath& crx_path) {
   // This function owns the file at |crx_path| and the |context| object.
-  ComponentUnpacker unpacker(context->pk_hash,
-                             crx_path,
-                             context->fingerprint,
-                             component_patcher_.get(),
-                             context->installer);
+  unpacker_.reset(new ComponentUnpacker(context->pk_hash,
+                                        crx_path,
+                                        context->fingerprint,
+                                        component_patcher_.get(),
+                                        context->installer,
+                                        blocking_task_runner_));
+  unpacker_->Unpack(base::Bind(&CrxUpdateService::DoneUnpacking,
+                               base::Unretained(this),
+                               context->id,
+                               crx_path));
+}
+
+// Do some cleanup before we skip back to the UI thread.

[Sorin Jianu, 2014/01/25 02:30:21]

This comment is more an implementation comment than a function comment. Might
want to remove it completely.

[waffles, 2014/01/28 21:06:31]

Done.

+void CrxUpdateService::DoneUnpacking(
+    const std::string& component_id,
+    const base::FilePath& crx_path,
+    ComponentUnpacker::Error error,
+    int extended_error) {
   if (!DeleteFileAndEmptyParentDirectory(crx_path))
     NOTREACHED() << crx_path.value();
-
-  // Why unretained? See comment at top of file.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CrxUpdateService::DoneInstalling, base::Unretained(this),
-                 context->id, unpacker.error(), unpacker.extended_error()),
+                 component_id, error, extended_error),
       base::TimeDelta::FromMilliseconds(config_->StepDelay()));
 }
 
 // Installation has been completed. Adjust the component status and
 // schedule the next check. Schedule a short delay before trying the full
 // update when the differential update failed.
 void CrxUpdateService::DoneInstalling(const std::string& component_id,
                                       ComponentUnpacker::Error error,
                                       int extra_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 119 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