Change the default cookie policy to be closer to the default in WebKit's Dump...

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 20 matching lines @@
 // alternate implementation that defers fetching to another process.
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
+#include "net/base/cookie_policy.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.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/appcache/appcache_interfaces.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/tools/test_shell/simple_appcache_system.h"
 #include "webkit/tools/test_shell/test_shell_request_context.h"
 
 using webkit_glue::ResourceLoaderBridge;
+using net::CookiePolicy;
 using net::HttpResponseHeaders;
 
 namespace {
 
 //-----------------------------------------------------------------------------
 
 URLRequestContext* request_context = NULL;
 base::Thread* io_thread = NULL;
 
 class IOThread : public base::Thread {
@@ skipping 581 matching lines @@
   // Make sure to stop any existing IO thread since it may be using the
   // current request context.
   Shutdown();
 
   if (context) {
     request_context = context;
   } else {
     request_context = new TestShellRequestContext();
   }
   request_context->AddRef();
+  SimpleResourceLoaderBridge::SetAcceptAllCookies(false);
 }
 
 // static
 void SimpleResourceLoaderBridge::Shutdown() {
   if (io_thread) {
     delete io_thread;
     io_thread = NULL;
 
     DCHECK(!request_context) << "should have been nulled by thread dtor";
   }
 }
 
+// static
 void SimpleResourceLoaderBridge::SetCookie(const GURL& url,
                                            const GURL& first_party_for_cookies,
                                            const std::string& cookie) {
   // Proxy to IO thread to synchronize w/ network loading.
 
   if (!EnsureIOThread()) {
     NOTREACHED();
     return;
   }
 
   scoped_refptr<CookieSetter> cookie_setter = new CookieSetter();
   io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       cookie_setter.get(), &CookieSetter::Set, url, cookie));
 }
 
+// static
 std::string SimpleResourceLoaderBridge::GetCookies(
     const GURL& url, const GURL& first_party_for_cookies) {
   // Proxy to IO thread to synchronize w/ network loading
 
   if (!EnsureIOThread()) {
     NOTREACHED();
     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();
 }
 
+// static
 bool SimpleResourceLoaderBridge::EnsureIOThread() {
   if (io_thread)
     return true;
 
   if (!request_context)
     SimpleResourceLoaderBridge::Init(NULL);
 
   io_thread = new IOThread();
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   return io_thread->StartWithOptions(options);
 }
+
+// static
+void SimpleResourceLoaderBridge::SetAcceptAllCookies(bool accept_all_cookies) {
+  CookiePolicy::Type policy_type = accept_all_cookies ?
+      CookiePolicy::ALLOW_ALL_COOKIES : CookiePolicy::BLOCK_THIRD_PARTY_COOKIES;
+  request_context->cookie_policy()->set_type(policy_type);
+}