Fix webkit URLRequestJob subtypes to handle Kill() correctly.

webkit/blob/blob_url_request_job.cc

 // Copyright (c) 20010 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 "webkit/blob/blob_url_request_job.h"
 
+#include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_status.h"
 
 namespace webkit_blob {
 
 static const int kHTTPOk = 200;
 static const int kHTTPPartialContent = 206;
 static const int kHTTPNotAllowed = 403;
 static const int kHTTPNotFound = 404;
 static const int kHTTPMethodNotAllow = 405;
 static const int kHTTPRequestedRangeNotSatisfiable = 416;
 static const int kHTTPInternalError = 500;
 
-static const char* kHTTPOKText = "OK";
-static const char* kHTTPPartialContentText = "Partial Content";
-static const char* kHTTPNotAllowedText = "Not Allowed";
-static const char* kHTTPNotFoundText = "Not Found";
-static const char* kHTTPMethodNotAllowText = "Method Not Allowed";
-static const char* kHTTPRequestedRangeNotSatisfiableText =
+static const char kHTTPOKText[] = "OK";
+static const char kHTTPPartialContentText[] = "Partial Content";
+static const char kHTTPNotAllowedText[] = "Not Allowed";
+static const char kHTTPNotFoundText[] = "Not Found";
+static const char kHTTPMethodNotAllowText[] = "Method Not Allowed";
+static const char kHTTPRequestedRangeNotSatisfiableText[] =
     "Requested Range Not Satisfiable";
-static const char* kHTTPInternalErrorText = "Internal Server Error";
+static const char kHTTPInternalErrorText[] = "Internal Server Error";
 
 BlobURLRequestJob::BlobURLRequestJob(
     net::URLRequest* request,
     BlobData* blob_data,
     base::MessageLoopProxy* file_thread_proxy)
     : URLRequestJob(request),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       blob_data_(blob_data),
       file_thread_proxy_(file_thread_proxy),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &BlobURLRequestJob::DidRead)),
       item_index_(0),
       total_size_(0),
       current_item_offset_(0),
       remaining_bytes_(0),
       read_buf_offset_(0),
       read_buf_size_(0),
       read_buf_remaining_bytes_(0),
       error_(false),
       headers_set_(false),
-      byte_range_set_(false) {
+      byte_range_set_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
 }
 
 BlobURLRequestJob::~BlobURLRequestJob() {
 }
 
 void BlobURLRequestJob::Start() {
   // Continue asynchronously.
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &BlobURLRequestJob::DidStart));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(&BlobURLRequestJob::DidStart));
 }
 
 void BlobURLRequestJob::DidStart() {
   // We only support GET request per the spec.
   if (request()->method() != "GET") {
     NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
     return;
   }
 
   // If the blob data is not present, bail out.
   if (!blob_data_) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   CountSize();
 }
 
 void BlobURLRequestJob::Kill() {
   stream_.Close();
 
   URLRequestJob::Kill();
+  callback_factory_.RevokeAll();
+  method_factory_.RevokeAll();
 }
 
 void BlobURLRequestJob::ResolveFile(const FilePath& file_path) {
   // If the file thread proxy is provided, we can use it get the file info.
   if (file_thread_proxy_) {
     base::FileUtilProxy::GetFileInfo(
           file_thread_proxy_,
           file_path,
           callback_factory_.NewCallback(&BlobURLRequestJob::DidResolve));
     return;
   }
 
   // Otherwise, we use current thread, i.e. IO thread, as this is the case when
   // we run the unittest or test shell.
   // TODO(jianli): Consider using the proxy of current thread.
   base::PlatformFileInfo file_info;
   bool exists = file_util::GetFileInfo(file_path, &file_info);
 
   // Continue asynchronously.
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &BlobURLRequestJob::DidResolve,
-      (exists ? base::PLATFORM_FILE_OK : base::PLATFORM_FILE_ERROR_NOT_FOUND),
-      file_info));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &BlobURLRequestJob::DidResolve,
+          exists ? base::PLATFORM_FILE_OK : base::PLATFORM_FILE_ERROR_NOT_FOUND,
+          file_info));
 }
 
 void BlobURLRequestJob::DidResolve(base::PlatformFileError rv,
                                    const base::PlatformFileInfo& file_info) {
-  // We may have been orphaned...
-  if (!request_)
-    return;
-
   // If an error occured, bail out.
   if (rv == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   } else if (rv != base::PLATFORM_FILE_OK) {
     NotifyFailure(net::ERR_FAILED);
     return;
   }
 
   // Validate the expected modification time.
@@ skipping 398 matching lines @@
         // We don't support multiple range requests in one single URL request,
         // because we need to do multipart encoding here.
         // TODO(jianli): Support multipart byte range requests.
         NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
       }
     }
   }
 }
 
 }  // namespace webkit_blob