base::Bind migrations in chrome/browser

chrome/browser/upgrade_detector_impl.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/upgrade_detector_impl.h"
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 41 matching lines @@
     return interval_ms * 1000;  // Command line value is in seconds.
 
   return kCheckForUpgradeMs;
 }
 
 // This task checks the currently running version of Chrome against the
 // installed version. If the installed version is newer, it runs the passed
 // callback task. Otherwise it just deletes the task.
 class DetectUpgradeTask : public Task {
  public:
-  DetectUpgradeTask(Task* upgrade_detected_task,
+  DetectUpgradeTask(base::Closure upgrade_detected_task,

[James Hawkins, 2011/11/16 22:31:36]

const base::Closure&

[csilv, 2011/11/16 22:43:23]

Done.

                     bool* is_unstable_channel,
                     bool* is_critical_upgrade)
       : upgrade_detected_task_(upgrade_detected_task),
         is_unstable_channel_(is_unstable_channel),
         is_critical_upgrade_(is_critical_upgrade) {
   }
 
   virtual ~DetectUpgradeTask() {
-    if (upgrade_detected_task_) {
+    if (!upgrade_detected_task_.is_null()) {
       // This has to get deleted on the same thread it was created.
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                              new DeleteTask<Task>(upgrade_detected_task_));
+                              upgrade_detected_task_);
     }
   }
 
   virtual void Run() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
     scoped_ptr<Version> installed_version;
     scoped_ptr<Version> critical_update;
 
 #if defined(OS_WIN)
@@ skipping 60 matching lines @@
         (installed_version->CompareTo(*running_version) > 0)) {
       // If a more recent version is available, it might be that we are lacking
       // a critical update, such as a zero-day fix.
       *is_critical_upgrade_ =
           critical_update.get() &&
           (critical_update->CompareTo(*running_version) > 0);
 
       // Fire off the upgrade detected task.
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               upgrade_detected_task_);
-      upgrade_detected_task_ = NULL;
+      upgrade_detected_task_.Reset();
     }
   }
 
  private:
-  Task* upgrade_detected_task_;
+  base::Closure upgrade_detected_task_;
   bool* is_unstable_channel_;
   bool* is_critical_upgrade_;
 };
 
 }  // namespace
 
 UpgradeDetectorImpl::UpgradeDetectorImpl()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       is_unstable_channel_(false) {
   CommandLine command_line(*CommandLine::ForCurrentProcess());
   if (command_line.HasSwitch(switches::kDisableBackgroundNetworking))
     return;
   // Windows: only enable upgrade notifications for official builds.
   // Mac: only enable them if the updater (Keystone) is present.
   // Linux (and other POSIX): always enable regardless of branding.
 #if (defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)) || defined(OS_POSIX)
 #if defined(OS_MACOSX)
   if (keystone_glue::KeystoneEnabled())
 #endif
   {
     detect_upgrade_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(GetCheckForUpgradeEveryMs()),
         this, &UpgradeDetectorImpl::CheckForUpgrade);
   }
 #endif
 }
 
 UpgradeDetectorImpl::~UpgradeDetectorImpl() {
 }
 
 void UpgradeDetectorImpl::CheckForUpgrade() {
-  method_factory_.RevokeAll();
-  Task* callback_task =
-      method_factory_.NewRunnableMethod(&UpgradeDetectorImpl::UpgradeDetected);
+  weak_factory_.InvalidateWeakPtrs();
+  base::Closure callback_task =
+      base::Bind(&UpgradeDetectorImpl::UpgradeDetected,
+                 weak_factory_.GetWeakPtr());
   // We use FILE as the thread to run the upgrade detection code on all
   // platforms. For Linux, this is because we don't want to block the UI thread
   // while launching a background process and reading its output; on the Mac and
   // on Windows checking for an upgrade requires reading a file.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           new DetectUpgradeTask(callback_task,
                                                 &is_unstable_channel_,
                                                 &is_critical_upgrade_));
 }
 
@@ skipping 73 matching lines @@
 
 // static
 UpgradeDetectorImpl* UpgradeDetectorImpl::GetInstance() {
   return Singleton<UpgradeDetectorImpl>::get();
 }
 
 // static
 UpgradeDetector* UpgradeDetector::GetInstance() {
   return UpgradeDetectorImpl::GetInstance();
 }