Offload disk accesses to WorkerPool in ExtensionProtocolHandler

webkit/appcache/view_appcache_internals_job.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 <algorithm>
 #include <string>
 
 #include "webkit/appcache/view_appcache_internals_job.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/view_cache_helper.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_service.h"
 
@@ skipping 295 matching lines @@
 
   virtual void Start() {
     DCHECK(request_);
     info_collection_ = new AppCacheInfoCollection;
     appcache_service_->GetAllAppCacheInfo(
         info_collection_, base::Bind(&MainPageJob::OnGotInfoComplete,
                                      weak_factory_.GetWeakPtr()));
   }
 
   // Produces a page containing the listing
-  virtual bool GetData(std::string* mime_type,
-                       std::string* charset,
-                       std::string* out) const {
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* out,
+                      const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
 
     out->clear();
     EmitPageStart(out);
     if (!info_collection_.get()) {
       out->append(kErrorMessage);
     } else if (info_collection_->infos_by_origin.empty()) {
       out->append(kEmptyAppCachesMessage);
     } else {
       typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
       AppCacheInfoVector appcaches;
       for (InfoByOrigin::const_iterator origin =
                info_collection_->infos_by_origin.begin();
            origin != info_collection_->infos_by_origin.end(); ++origin) {
         appcaches.insert(appcaches.end(),
                          origin->second.begin(), origin->second.end());
       }
       std::sort(appcaches.begin(), appcaches.end(), SortByManifestUrl);
 
       GURL base_url = ClearQuery(request_->url());
       EmitAppCacheInfoVector(base_url, appcache_service_, appcaches, out);
     }
     EmitPageEnd(out);
-    return true;
+    return net::OK;
   }
 
  private:
   virtual ~MainPageJob() {}
 
   void OnGotInfoComplete(int rv) {
     if (rv != net::OK)
       info_collection_ = NULL;
     StartAsync();
   }
 
   base::WeakPtrFactory<MainPageJob> weak_factory_;
   scoped_refptr<AppCacheInfoCollection> info_collection_;
   DISALLOW_COPY_AND_ASSIGN(MainPageJob);
 };
 
 // Job that redirects back to the main appcache internals page.
 class RedirectToMainPageJob : public BaseInternalsJob {
  public:
   RedirectToMainPageJob(net::URLRequest* request, AppCacheService* service)
       : BaseInternalsJob(request, service) {}
 
-  virtual bool GetData(std::string* mime_type,
-                       std::string* charset,
-                       std::string* data) const {
-    return true;  // IsRedirectResponse induces a redirect.
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* data,
+                      const net::CompletionCallback& callback) const OVERRIDE {
+    return net::OK;  // IsRedirectResponse induces a redirect.
   }
 
   virtual bool IsRedirectResponse(GURL* location, int* http_status_code) {
     *location = ClearQuery(request_->url());
     *http_status_code = 307;
     return true;
   }
 
  protected:
   virtual ~RedirectToMainPageJob() {}
@@ skipping 39 matching lines @@
       const GURL& manifest_url)
       : BaseInternalsJob(request, service),
         manifest_url_(manifest_url) {}
 
   virtual void Start() {
     DCHECK(request_);
     appcache_service_->storage()->LoadOrCreateGroup(manifest_url_, this);
   }
 
   // Produces a page containing the entries listing.
-  virtual bool GetData(std::string* mime_type,
-                       std::string* charset,
-                       std::string* out) const {
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* out,
+                      const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     if (appcache_info_.manifest_url.is_empty()) {
       out->append(kManifestNotFoundMessage);
     } else {
       GURL base_url = ClearQuery(request_->url());
       EmitAppCacheInfo(base_url, appcache_service_, &appcache_info_, out);
       EmitAppCacheResourceInfoVector(base_url,
                                      manifest_url_,
                                      resource_infos_,
                                      appcache_info_.group_id,
                                      out);
     }
     EmitPageEnd(out);
-    return true;
+    return net::OK;
   }
 
  private:
   virtual ~ViewAppCacheJob() {
     appcache_service_->storage()->CancelDelegateCallbacks(this);
   }
 
   // AppCacheStorage::Delegate override
   virtual void OnGroupLoaded(
       AppCacheGroup* group, const GURL& manifest_url) OVERRIDE {
@@ skipping 32 matching lines @@
         response_id_(response_id), group_id_(group_id), amount_read_(0) {
   }
 
   virtual void Start() {
     DCHECK(request_);
     appcache_service_->storage()->LoadResponseInfo(
         manifest_url_, group_id_, response_id_, this);
   }
 
   // Produces a page containing the response headers and data.
-  virtual bool GetData(std::string* mime_type,
-                       std::string* charset,
-                       std::string* out) const {
+  virtual int GetData(std::string* mime_type,
+                      std::string* charset,
+                      std::string* out,
+                      const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     EmitAnchor(entry_url_.spec(), entry_url_.spec(), out);
     out->append("<br/>\n");
     if (response_info_) {
       if (response_info_->http_response_info())
         EmitResponseHeaders(response_info_->http_response_info()->headers, out);
       else
         out->append("Failed to read response headers.<br>");
 
       if (response_data_) {
         EmitHexDump(response_data_->data(), amount_read_,
                     response_info_->response_data_size(), out);
       } else {
         out->append("Failed to read response data.<br>");
       }
     } else {
       out->append("Failed to read response headers and data.<br>");
     }
     EmitPageEnd(out);
-    return true;
+    return net::OK;
   }
 
  private:
   virtual ~ViewEntryJob() {
     appcache_service_->storage()->CancelDelegateCallbacks(this);
   }
 
   virtual void OnResponseInfoLoaded(
       AppCacheResponseInfo* response_info, int64 response_id) OVERRIDE {
     if (!response_info) {
@@ skipping 61 matching lines @@
     return new ViewEntryJob(request, service,
                             DecodeBase64URL(tokens[0]),  // manifest url
                             DecodeBase64URL(tokens[1]),  // entry url
                             response_id, group_id);
   }
 
   return new RedirectToMainPageJob(request, service);
 }
 
 }  // namespace appcache