Support asynchronous patching operations in the component updater.

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 331 matching lines @@
   bool AddItemToUpdateCheck(CrxUpdateItem* item, std::string* query);
 
   void ProcessPendingItems();
 
   void ScheduleNextRun(StepDelayInterval step_delay);
 
   void ParseManifest(const std::string& xml);
 
   void Install(const CRXContext* context, const base::FilePath& crx_path);
 
+  void DoneUnpacking(const std::string& component_id,
+                     const base::FilePath& crx_path,
+                     component_updater::Error error,
+                     int extended_error);
+
   void DoneInstalling(const std::string& component_id,
-                      ComponentUnpacker::Error error,
+                      component_updater::Error error,
                       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;
 
@@ skipping 551 matching lines @@
 }
 
 // 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 base::FilePath& crx_path) {
   // This function owns the |crx_path| and the |context| object.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  ComponentUnpacker unpacker(context->pk_hash,
-                             crx_path,
-                             context->fingerprint,
-                             component_patcher_.get(),
-                             context->installer);
+  component_updater::Unpack(context->pk_hash,
+                            crx_path,
+                            context->fingerprint,
+                            component_patcher_.get(),
+                            context->installer,
+                            base::Bind(&CrxUpdateService::DoneUnpacking,
+                                       base::Unretained(this),
+                                       context->id,
+                                       crx_path));
+  delete context;
+}
+
+// Do some cleanup before we skip back to the UI thread.
+void CrxUpdateService::DoneUnpacking(const std::string& component_id,
+                                     const base::FilePath& crx_path,
+                                     component_updater::Error error,
+                                     int extended_error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!base::DeleteFile(crx_path, false))
     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()));
-  delete context;
 }
 
 // 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,
+                                      component_updater::Error error,
                                       int extra_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ErrorCategory error_category = kErrorNone;
   switch (error) {
-    case ComponentUnpacker::kNone:
+    case component_updater::kNone:
       break;
-    case ComponentUnpacker::kInstallerError:
+    case component_updater::kInstallerError:
       error_category = kInstallError;
       break;
     default:
       error_category = kUnpackError;
       break;
   }
 
-  const bool is_success = error == ComponentUnpacker::kNone;
+  const bool is_success = error == component_updater::kNone;
 
   CrxUpdateItem* item = FindUpdateItemById(component_id);
   if (item->status == CrxUpdateItem::kUpdatingDiff && !is_success) {
     item->diff_error_category = error_category;
     item->diff_error_code = error;
     item->diff_extra_code1 = extra_code;
     item->diff_update_failed = true;
     size_t count = ChangeItemStatus(CrxUpdateItem::kUpdatingDiff,
                                     CrxUpdateItem::kCanUpdate);
     DCHECK_EQ(count, 1ul);
@@ skipping 28 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);
 }