base::Bind: Convert view_http_cache_job_factory.cc.

chrome/browser/net/view_http_cache_job_factory.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/net/view_http_cache_job_factory.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
-#include "base/task.h"
 #include "chrome/common/url_constants.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/view_cache_helper.h"
 
 namespace {
 
 // A job subclass that dumps an HTTP cache entry.
 class ViewHttpCacheJob : public net::URLRequestJob {
  public:
   explicit ViewHttpCacheJob(net::URLRequest* request)
       : net::URLRequestJob(request),
         core_(new Core),
-        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(NewCallback(this,
-                                  &ViewHttpCacheJob::OnStartCompleted))) {}
+            callback_(base::Bind(&ViewHttpCacheJob::OnStartCompleted,
+                                 base::Unretained(this)))) {
+  }
 
-  virtual void Start();
-  virtual void Kill();
-  virtual bool GetMimeType(std::string* mime_type) const {
+  // net::URLRequestJob implementation.
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE{
     return core_->GetMimeType(mime_type);
   }
-  virtual bool GetCharset(std::string* charset) {
+  virtual bool GetCharset(std::string* charset) OVERRIDE{
     return core_->GetCharset(charset);
   }
-  virtual bool ReadRawData(net::IOBuffer* buf, int buf_size, int *bytes_read) {
+  virtual bool ReadRawData(net::IOBuffer* buf,
+                           int buf_size, int *bytes_read) OVERRIDE{
     return core_->ReadRawData(buf, buf_size, bytes_read);
   }
 
  private:
   class Core : public base::RefCounted<Core> {
    public:
     Core()
         : data_offset_(0),
-          ALLOW_THIS_IN_INITIALIZER_LIST(
-              callback_(this, &Core::OnIOComplete)),

[csilv, 2011/11/23 18:37:32]

I'm a little unclear what this old implementation was doing.  isn't there a
missing 'NewCallback'...?

-          user_callback_(NULL) {}
+          ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+              base::Bind(&Core::OnIOComplete, this))) {
+    }
 
-    int Start(const net::URLRequest& request, Callback0::Type* callback);
+    int Start(const net::URLRequest& request, const base::Closure& callback);
 
     // Prevents it from invoking its callback. It will self-delete.
     void Orphan() {
-      user_callback_ = NULL;
+      user_callback_.Reset();
     }
 
     bool GetMimeType(std::string* mime_type) const;
     bool GetCharset(std::string* charset);
     bool ReadRawData(net::IOBuffer* buf, int buf_size, int *bytes_read);
 
    private:
     friend class base::RefCounted<Core>;
 
     ~Core() {}
 
     // Called when ViewCacheHelper completes the operation.
     void OnIOComplete(int result);
 
     std::string data_;
     int data_offset_;
     net::ViewCacheHelper cache_helper_;
-    net::OldCompletionCallbackImpl<Core> callback_;
-    Callback0::Type* user_callback_;
+    net::CompletionCallback callback_;
+    base::Closure user_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   ~ViewHttpCacheJob() {}
 
   void StartAsync();
   void OnStartCompleted();
 
   scoped_refptr<Core> core_;
-  ScopedRunnableMethodFactory<ViewHttpCacheJob> method_factory_;
-  scoped_ptr<Callback0::Type> callback_;
+  base::WeakPtrFactory<ViewHttpCacheJob> weak_factory_;
+  base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewHttpCacheJob);
 };
 
 void ViewHttpCacheJob::Start() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&ViewHttpCacheJob::StartAsync));
+      base::Bind(&ViewHttpCacheJob::StartAsync, weak_factory_.GetWeakPtr()));
 }
 
 void ViewHttpCacheJob::Kill() {
-  method_factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   if (core_) {
     core_->Orphan();
     core_ = NULL;
   }
   net::URLRequestJob::Kill();
 }
 
 void ViewHttpCacheJob::StartAsync() {
   DCHECK(request());
 
   if (!request())
     return;
 
-  int rv = core_->Start(*request(), callback_.get());
+  int rv = core_->Start(*request(), callback_);
   if (rv != net::ERR_IO_PENDING) {
     DCHECK_EQ(net::OK, rv);
     OnStartCompleted();
   }
 }
 
 void ViewHttpCacheJob::OnStartCompleted() {
   NotifyHeadersComplete();
 }
 
 int ViewHttpCacheJob::Core::Start(const net::URLRequest& request,
-                                  Callback0::Type* callback) {
-  DCHECK(callback);
-  DCHECK(!user_callback_);
+                                  const base::Closure& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(user_callback_.is_null());
 
   AddRef();  // Released on OnIOComplete().
   std::string cache_key =
       request.url().spec().substr(strlen(chrome::kChromeUINetworkViewCacheURL));
 
   int rv;
   if (cache_key.empty()) {
     rv = cache_helper_.GetContentsHTML(request.context(),
                                        chrome::kChromeUINetworkViewCacheURL,
-                                       &data_,
-                                       &callback_);
+                                       &data_, callback_);
   } else {
     rv = cache_helper_.GetEntryInfoHTML(cache_key, request.context(),
-                                        &data_, &callback_);
+                                        &data_, callback_);
   }
 
   if (rv == net::ERR_IO_PENDING)
     user_callback_ = callback;
 
   return rv;
 }
 
 bool ViewHttpCacheJob::Core::GetMimeType(std::string* mime_type) const {
   mime_type->assign("text/html");
@@ skipping 14 matching lines @@
     buf_size = remaining;
   memcpy(buf->data(), data_.data() + data_offset_, buf_size);
   data_offset_ += buf_size;
   *bytes_read = buf_size;
   return true;
 }
 
 void ViewHttpCacheJob::Core::OnIOComplete(int result) {
   DCHECK_EQ(net::OK, result);
 
-  if (user_callback_)
-    user_callback_->Run();
+  if (!user_callback_.is_null())
+    user_callback_.Run();
 
   // We may be holding the last reference to this job. Do not access |this|
   // after Release().
   Release();  // Acquired on Start().
 }
 
 }  // namespace.
 
 // Static.
 bool ViewHttpCacheJobFactory::IsSupportedURL(const GURL& url) {
   return url.SchemeIs(chrome::kChromeUIScheme) &&
          url.host() == chrome::kChromeUINetworkViewCacheHost;
 }
 
 // Static.
 net::URLRequestJob* ViewHttpCacheJobFactory::CreateJobForRequest(
     net::URLRequest* request) {
   return new ViewHttpCacheJob(request);
 }