Do cookie checks in NetworkDelegate instead of the URLRequest::Delegate.

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 34 matching lines @@
 #include "base/timer.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/cookie_store.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
+#include "net/base/network_delegate.h"
 #include "net/base/static_cookie_policy.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_storage_controller.h"
 #include "webkit/blob/blob_url_request_job.h"
@@ skipping 28 matching lines @@
       bool in_no_proxy)
       : cache_path(in_cache_path),
         cache_mode(in_cache_mode),
         no_proxy(in_no_proxy) {}
 
   FilePath cache_path;
   net::HttpCache::Mode cache_mode;
   bool no_proxy;
 };
 
+//-----------------------------------------------------------------------------
+
+bool g_accept_all_cookies = false;
+
+class TestShellNetworkDelegate : public net::NetworkDelegate {
+ public:
+  virtual ~TestShellNetworkDelegate() {}
+
+ private:
+  // net::NetworkDelegate implementation.
+  virtual int OnBeforeURLRequest(net::URLRequest* request,
+                                 const net::CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE {
+    return net::OK;
+  }
+  virtual int OnBeforeSendHeaders(net::URLRequest* request,
+                                  const net::CompletionCallback& callback,
+                                  net::HttpRequestHeaders* headers) OVERRIDE {
+    return net::OK;
+  }
+  virtual void OnSendHeaders(net::URLRequest* request,
+                             const net::HttpRequestHeaders& headers) OVERRIDE {}
+  virtual int OnHeadersReceived(
+      net::URLRequest* request,
+      const net::CompletionCallback& callback,
+      net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>*
+          override_response_headers) OVERRIDE {
+    return net::OK;
+  }
+  virtual void OnBeforeRedirect(net::URLRequest* request,
+                                const GURL& new_location) OVERRIDE {}
+  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {}
+  virtual void OnRawBytesRead(const net::URLRequest& request,
+                              int bytes_read) OVERRIDE {}
+  virtual void OnCompleted(net::URLRequest* request, bool started) OVERRIDE {}
+  virtual void OnURLRequestDestroyed(net::URLRequest* request) OVERRIDE {}
+
+  virtual void OnPACScriptError(int line_number,
+                                const string16& error) OVERRIDE {
+  }
+  virtual AuthRequiredResponse OnAuthRequired(
+      net::URLRequest* request,
+      const net::AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      net::AuthCredentials* credentials) OVERRIDE {
+    return AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+  virtual bool CanGetCookies(
+      const net::URLRequest* request,
+      const net::CookieList& cookie_list) OVERRIDE {
+    StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
+        StaticCookiePolicy::ALLOW_ALL_COOKIES :
+        StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
+
+    StaticCookiePolicy policy(policy_type);
+    int rv = policy.CanGetCookies(
+        request->url(), request->first_party_for_cookies());
+    return rv == net::OK;
+  }
+  virtual bool CanSetCookie(const net::URLRequest* request,
+                            const std::string& cookie_line,
+                            net::CookieOptions* options) OVERRIDE {
+    StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
+        StaticCookiePolicy::ALLOW_ALL_COOKIES :
+        StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
+
+    StaticCookiePolicy policy(policy_type);
+    int rv = policy.CanSetCookie(
+        request->url(), request->first_party_for_cookies());
+    return rv == net::OK;
+  }
+};
+
 TestShellRequestContextParams* g_request_context_params = NULL;
 TestShellRequestContext* g_request_context = NULL;
+TestShellNetworkDelegate* g_network_delegate = NULL;
 base::Thread* g_cache_thread = NULL;
-bool g_accept_all_cookies = false;
 
 struct FileOverHTTPParams {
   FileOverHTTPParams(std::string in_file_path_template, GURL in_http_prefix)
       : file_path_template(in_file_path_template),
         http_prefix(in_http_prefix) {}
 
   std::string file_path_template;
   GURL http_prefix;
 };
 
@@ skipping 17 matching lines @@
           g_request_context_params->cache_mode,
           g_request_context_params->no_proxy);
       delete g_request_context_params;
       g_request_context_params = NULL;
     } else {
       g_request_context = new TestShellRequestContext();
     }
 
     g_request_context->AddRef();
 
+    g_network_delegate = new TestShellNetworkDelegate();
+    g_request_context->set_network_delegate(g_network_delegate);
+
     SimpleAppCacheSystem::InitializeOnIOThread(g_request_context);
     SimpleSocketStreamBridge::InitializeOnIOThread(g_request_context);
     SimpleFileWriter::InitializeOnIOThread(g_request_context);
     SimpleFileSystem::InitializeOnIOThread(
         g_request_context->blob_storage_controller());
     TestShellWebBlobRegistryImpl::InitializeOnIOThread(
         g_request_context->blob_storage_controller());
   }
 
   virtual void CleanUp() {
     // In reverse order of initialization.
     TestShellWebBlobRegistryImpl::Cleanup();
     SimpleFileSystem::CleanupOnIOThread();
     SimpleFileWriter::CleanupOnIOThread();
     SimpleSocketStreamBridge::Cleanup();
     SimpleAppCacheSystem::CleanupOnIOThread();
 
     if (g_request_context) {
+      g_request_context->set_network_delegate(NULL);
       g_request_context->Release();
       g_request_context = NULL;
     }
+
+    if (g_network_delegate) {
+      delete g_network_delegate;
+      g_network_delegate = NULL;
+    }
   }
 };
 
 IOThread* g_io_thread = NULL;
 
 //-----------------------------------------------------------------------------
 
 struct RequestParams {
   std::string method;
   GURL url;
@@ skipping 294 matching lines @@
     }
   }
 
   virtual void OnSSLCertificateError(net::URLRequest* request,
                                      const net::SSLInfo& ssl_info,
                                      bool fatal) OVERRIDE {
     // Allow all certificate errors.
     request->ContinueDespiteLastError();
   }
 
-  virtual bool CanGetCookies(
-      const net::URLRequest* request,
-      const net::CookieList& cookie_list) const OVERRIDE {
-    StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
-        StaticCookiePolicy::ALLOW_ALL_COOKIES :
-        StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
-
-    StaticCookiePolicy policy(policy_type);
-    int rv = policy.CanGetCookies(
-        request->url(), request->first_party_for_cookies());
-    return rv == net::OK;
-  }
-
-  virtual bool CanSetCookie(const net::URLRequest* request,
-                            const std::string& cookie_line,
-                            net::CookieOptions* options) const OVERRIDE {
-    StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
-        StaticCookiePolicy::ALLOW_ALL_COOKIES :
-        StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
-
-    StaticCookiePolicy policy(policy_type);
-    int rv = policy.CanSetCookie(
-        request->url(), request->first_party_for_cookies());
-    return rv == net::OK;
-  }
-
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE {
     if (request->status().is_success() && bytes_read > 0) {
       OnReceivedData(bytes_read);
     } else {
       Done();
     }
   }
 
   // --------------------------------------------------------------------------
@@ skipping 402 matching lines @@
 void SimpleResourceLoaderBridge::Init(
     const FilePath& cache_path,
     net::HttpCache::Mode cache_mode,
     bool no_proxy) {
   // Make sure to stop any existing IO thread since it may be using the
   // current request context.
   Shutdown();
 
   DCHECK(!g_request_context_params);
   DCHECK(!g_request_context);
+  DCHECK(!g_network_delegate);
   DCHECK(!g_io_thread);
 
   g_request_context_params = new TestShellRequestContextParams(
       cache_path, cache_mode, no_proxy);
 }
 
 // static
 void SimpleResourceLoaderBridge::Shutdown() {
   if (g_io_thread) {
     delete g_io_thread;
     g_io_thread = NULL;
 
     DCHECK(g_cache_thread);
     delete g_cache_thread;
     g_cache_thread = NULL;
 
     DCHECK(!g_request_context) << "should have been nulled by thread dtor";
+    DCHECK(!g_network_delegate) << "should have been nulled by thread dtor";
   } else {
     delete g_request_context_params;
     g_request_context_params = NULL;
 
     if (g_file_over_http_params) {
       delete g_file_over_http_params;
       g_file_over_http_params = NULL;
     }
   }
 }
@@ skipping 86 matching lines @@
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }