base::Bind() conversion for ComponentUpdaterService.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 2011 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"
+#include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/utility_process_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 
 using content::BrowserThread;
 
+// The component updater is designed to live until process shutdown, so
+// base::Bind() calls are not refcounted.
+
 namespace {
 // Extends an omaha compatible update check url |query| string. Does
 // not mutate the string if it would be longer than |limit| chars.
 bool AddQueryString(std::string id, std::string version,
                     size_t limit, std::string* query) {
   std::string additional =
       base::StringPrintf("id=%s&v=%s&uc", id.c_str(), version.c_str());
   additional = "x=" + net::EscapeQueryParamValue(additional, true);
   if ((additional.size() + query->size() + 1) > limit)
     return false;
@@ skipping 270 matching lines @@
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   Version chrome_version_;
 
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
 
-// The component updater is designed to live until process shutdown, besides
-// we can't be refcounted because we are a singleton.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(CrxUpdateService);
-
 //////////////////////////////////////////////////////////////////////////////
 
 CrxUpdateService::CrxUpdateService(
     ComponentUpdateService::Configurator* config)
     : config_(config),
       chrome_version_(chrome::VersionInfo().Version()),
       running_(false) {
 }
 
 CrxUpdateService::~CrxUpdateService() {
@@ skipping 347 matching lines @@
                                     CrxUpdateItem::kUpdating);
     DCHECK_EQ(count, 1ul);
     url_fetcher_.reset();
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_READY,
         content::Source<std::string>(&context->id),
         content::NotificationService::NoDetails());
 
     BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(this, &CrxUpdateService::Install,
-                          context,
-                          temp_crx_path),
+        base::Bind(&CrxUpdateService::Install,
+                   base::Unretained(this),

[asargent_no_longer_on_chrome, 2011/11/21 18:00:16]

optional suggestion: add comment near the base:Unretained here that says
something like 

// Why Unretained? See comment at top of file.
 

+                   context,
+                   temp_crx_path),
         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
 // the files created.
 void CrxUpdateService::Install(const CRXContext* context,
                                const 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->installer);
   if (!file_util::Delete(crx_path, false)) {
     NOTREACHED() << crx_path.value();
   }
   BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &CrxUpdateService::DoneInstalling,
-                        context->id, unpacker.error()),
+      base::Bind(&CrxUpdateService::DoneInstalling, base::Unretained(this),

[asargent_no_longer_on_chrome, 2011/11/21 18:00:16]

same suggestion here

+                 context->id, unpacker.error()),
       config_->StepDelay());
   delete context;
 }
 
 // Installation has been completed. Adjust the component status and
 // schedule the next check.
 void CrxUpdateService::DoneInstalling(const std::string& component_id,
                                       ComponentUnpacker::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 20 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);
 }