AppCachePlumbing

webkit/tools/test_shell/simple_resource_loader_bridge.cc

 // Copyright (c) 2006-2008 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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using URLRequest, meaning it is a "simple" version
 // that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because URLRequest only provides an asynchronous resource loading API, this
@@ skipping 28 matching lines @@
 #include "base/waitable_event.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_loader_bridge.h"
+#include "webkit/glue/webappcachecontext.h"
 #include "webkit/tools/test_shell/test_shell_request_context.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using net::HttpResponseHeaders;
 
 namespace {
 
 //-----------------------------------------------------------------------------
 
 URLRequestContext* request_context = NULL;
@@ skipping 33 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 struct RequestParams {
   std::string method;
   GURL url;
   GURL policy_url;
   GURL referrer;
   std::string headers;
   int load_flags;
+  int app_cache_context_id;
   scoped_refptr<net::UploadData> upload;
 };
 
 // The interval for calls to RequestProxy::MaybeUpdateUploadProgress
 static const int kUpdateUploadProgressIntervalMsec = 100;
 
 // The RequestProxy does most of its work on the IO thread.  The Start and
 // Cancel methods are proxied over to the IO thread, where an URLRequest object
 // is instantiated.
 class RequestProxy : public URLRequest::Delegate,
@@ skipping 168 matching lines @@
     DCHECK(request->status().is_success());
     OnReceivedRedirect(new_url);
   }
 
   virtual void OnResponseStarted(URLRequest* request) {
     if (request->status().is_success()) {
       ResourceLoaderBridge::ResponseInfo info;
       info.request_time = request->request_time();
       info.response_time = request->response_time();
       info.headers = request->response_headers();
+      info.app_cache_id = WebAppCacheContext::kNoAppCacheId;
       request->GetMimeType(&info.mime_type);
       request->GetCharset(&info.charset);
       info.content_length = request->GetExpectedContentSize();
       OnReceivedResponse(info, false);
       AsyncReadData();  // start reading
     } else {
       Done();
     }
   }
 
@@ skipping 120 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 class ResourceLoaderBridgeImpl : public ResourceLoaderBridge {
  public:
   ResourceLoaderBridgeImpl(const std::string& method,
                            const GURL& url,
                            const GURL& policy_url,
                            const GURL& referrer,
                            const std::string& headers,
-                           int load_flags)
+                           int load_flags,
+                           int app_cache_context_id)
       : params_(new RequestParams),
         proxy_(NULL) {
     params_->method = method;
     params_->url = url;
     params_->policy_url = policy_url;
     params_->referrer = referrer;
     params_->headers = headers;
     params_->load_flags = load_flags;
+    params_->app_cache_context_id = app_cache_context_id;
   }
 
   virtual ~ResourceLoaderBridgeImpl() {
     if (proxy_) {
       proxy_->DropPeer();
       // Let the proxy die on the IO thread
       io_thread->message_loop()->ReleaseSoon(FROM_HERE, proxy_);
     }
   }
 
@@ skipping 114 matching lines @@
     const GURL& url,
     const GURL& policy_url,
     const GURL& referrer,
     const std::string& frame_origin,
     const std::string& main_frame_origin,
     const std::string& headers,
     const std::string& default_mime_type,
     int load_flags,
     int requestor_pid,
     ResourceType::Type request_type,
+    int app_cache_context_id,
     int routing_id) {
   return new ResourceLoaderBridgeImpl(method, url, policy_url,
-                                      referrer, headers, load_flags);
+                                      referrer, headers, load_flags,
+                                      app_cache_context_id);
 }
 
 // Issue the proxy resolve request on the io thread, and wait
 // for the result.
 bool FindProxyForUrl(const GURL& url, std::string* proxy_list) {
   DCHECK(request_context);
 
   scoped_refptr<net::SyncProxyServiceHelper> sync_proxy_service(
       new net::SyncProxyServiceHelper(io_thread->message_loop(),
       request_context->proxy_service()));
@@ skipping 58 matching lines @@
     return std::string();
   }
 
   scoped_refptr<CookieGetter> getter = new CookieGetter();
 
   io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       getter.get(), &CookieGetter::Get, url));
 
   return getter->GetResult();
 }