Use base::PostTaskAndReplyWithResults() in more places.

chrome/browser/extensions/extension_protocols.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/extensions/extension_protocols.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/compiler_specific.h"
@@ skipping 38 matching lines @@
 #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/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/url_util.h"
 
+using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::Extension;
 using extensions::SharedModuleInfo;
 
 namespace {
 
 net::HttpResponseHeaders* BuildHttpHeaders(
     const std::string& content_security_policy, bool send_cors_header,
     const base::Time& last_modified_time) {
   std::string raw_headers;
@@ skipping 24 matching lines @@
       // Also force revalidation.
       raw_headers.append(1, '\0');
       raw_headers.append("cache-control: no-cache");
     }
   }
 
   raw_headers.append(2, '\0');
   return new net::HttpResponseHeaders(raw_headers);
 }
 
-void ReadMimeTypeFromFile(const base::FilePath& filename,
-                          std::string* mime_type,
-                          bool* result) {
-  *result = net::GetMimeTypeFromFile(filename, mime_type);
-}
-
 class URLRequestResourceBundleJob : public net::URLRequestSimpleJob {
  public:
   URLRequestResourceBundleJob(net::URLRequest* request,
                               net::NetworkDelegate* network_delegate,
                               const base::FilePath& filename,
                               int resource_id,
                               const std::string& content_security_policy,
                               bool send_cors_header)
       : net::URLRequestSimpleJob(request, network_delegate),
         filename_(filename),
@@ skipping 12 matching lines @@
                       const net::CompletionCallback& callback) const OVERRIDE {
     const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     *data = rb.GetRawDataResource(resource_id_).as_string();
 
     // Add the Content-Length header now that we know the resource length.
     response_info_.headers->AddHeader(base::StringPrintf(
         "%s: %s",  net::HttpRequestHeaders::kContentLength,
         base::UintToString(data->size()).c_str()));
 
     std::string* read_mime_type = new std::string;
-    bool* read_result = new bool;
-    bool posted = content::BrowserThread::PostBlockingPoolTaskAndReply(
+    bool posted = base::PostTaskAndReplyWithResult(
+        BrowserThread::GetBlockingPool(),
         FROM_HERE,
-        base::Bind(&ReadMimeTypeFromFile, filename_,
-                   base::Unretained(read_mime_type),
-                   base::Unretained(read_result)),
+        base::Bind(&net::GetMimeTypeFromFile, filename_,
+                   base::Unretained(read_mime_type)),
         base::Bind(&URLRequestResourceBundleJob::OnMimeTypeRead,
                    weak_factory_.GetWeakPtr(),
                    mime_type, charset, data,
                    base::Owned(read_mime_type),
-                   base::Owned(read_result),
                    callback));
     DCHECK(posted);
 
     return net::ERR_IO_PENDING;
   }
 
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE {
     *info = response_info_;
   }
 
  private:
   virtual ~URLRequestResourceBundleJob() { }
 
   void OnMimeTypeRead(std::string* out_mime_type,
                       std::string* charset,
                       std::string* data,
                       std::string* read_mime_type,
-                      bool* read_result,
-                      const net::CompletionCallback& callback) {
+                      const net::CompletionCallback& callback,
+                      bool read_result) {
     *out_mime_type = *read_mime_type;
     if (StartsWithASCII(*read_mime_type, "text/", false)) {
       // All of our HTML files should be UTF-8 and for other resource types
       // (like images), charset doesn't matter.
       DCHECK(IsStringUTF8(*data));
       *charset = "utf-8";
     }
-    int result = *read_result? net::OK: net::ERR_INVALID_URL;
+    int result = read_result ? net::OK : net::ERR_INVALID_URL;
     callback.Run(result);
   }
 
   // We need the filename of the resource to determine the mime type.
   base::FilePath filename_;
 
   // The resource bundle id to load.
   int resource_id_;
 
   net::HttpResponseInfo response_info_;
@@ skipping 98 matching lines @@
  public:
   URLRequestExtensionJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
                          const std::string& extension_id,
                          const base::FilePath& directory_path,
                          const base::FilePath& relative_path,
                          const std::string& content_security_policy,
                          bool send_cors_header)
     : net::URLRequestFileJob(
           request, network_delegate, base::FilePath(),
-          content::BrowserThread::GetBlockingPool()->
-              GetTaskRunnerWithShutdownBehavior(
+          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
       directory_path_(directory_path),
       // TODO(tc): Move all of these files into resources.pak so we don't break
       // when updating on Linux.
       resource_(extension_id, directory_path, relative_path),
       content_security_policy_(content_security_policy),
       send_cors_header_(send_cors_header),
       weak_factory_(this) {
   }
 
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE {
     *info = response_info_;
   }
 
   virtual void Start() OVERRIDE {
     base::FilePath* read_file_path = new base::FilePath;
     base::Time* last_modified_time = new base::Time();
-    bool posted = content::BrowserThread::PostBlockingPoolTaskAndReply(
+    bool posted = BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE,
         base::Bind(&ReadResourceFilePathAndLastModifiedTime, resource_,
                    directory_path_,
                    base::Unretained(read_file_path),
                    base::Unretained(last_modified_time)),
         base::Bind(&URLRequestExtensionJob::OnFilePathAndLastModifiedTimeRead,
                    weak_factory_.GetWeakPtr(),
                    base::Owned(read_file_path),
                    base::Owned(last_modified_time)));
     DCHECK(posted);
@@ skipping 302 matching lines @@
                                     send_cors_header);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     extensions::InfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }