Finalize a CL originally by departed intern ycxiao@ that detaches the loading of cookies from the...

webkit/tools/test_shell/simple_resource_loader_bridge.cc

 // Copyright (c) 2011 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 14 matching lines @@
 //                                        -> net_util::GetCookies
 //
 // NOTE: The implementation in this file may be used to have WebKit fetch
 // resources in-process.  For example, it is handy for building a single-
 // process WebKit embedding (e.g., test_shell) that can use net::URLRequest to
 // perform URL loads.  See renderer/resource_dispatcher.h for details on an
 // alternate implementation that defers fetching to another process.
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/memory/ref_counted.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/threading/thread.h"
@@ skipping 693 matching lines @@
   // sticks around until this ResourceLoaderBridge is destroyed.
   RequestProxy* proxy_;
 };
 
 //-----------------------------------------------------------------------------
 
 class CookieSetter : public base::RefCountedThreadSafe<CookieSetter> {
  public:
   void Set(const GURL& url, const std::string& cookie) {
     DCHECK(MessageLoop::current() == g_io_thread->message_loop());
-    g_request_context->cookie_store()->SetCookie(url, cookie);
+    g_request_context->cookie_store()->SetCookieWithOptionsAsync(
+        url, cookie, net::CookieOptions(),
+        net::CookieStore::SetCookiesCallback());
   }
 
  private:
+
   friend class base::RefCountedThreadSafe<CookieSetter>;
 
   ~CookieSetter() {}
 };
 
 class CookieGetter : public base::RefCountedThreadSafe<CookieGetter> {
  public:
   CookieGetter() : event_(false, false) {
   }
 
   void Get(const GURL& url) {
-    result_ = g_request_context->cookie_store()->GetCookies(url);
-    event_.Signal();
+    g_request_context->cookie_store()->GetCookiesWithOptionsAsync(
+        url, net::CookieOptions(),
+        base::Bind(&CookieGetter::OnGetCookies, this));
   }
 
   std::string GetResult() {
     if (!event_.Wait())
       NOTREACHED();
     return result_;
   }
 
  private:
+  void OnGetCookies(const std::string& cookie_line) {
+    result_ = cookie_line;
+    event_.Signal();
+  }
   friend class base::RefCountedThreadSafe<CookieGetter>;
 
   ~CookieGetter() {}
 
   base::WaitableEvent event_;
   std::string result_;
 };
 
 }  // anonymous namespace
 
@@ skipping 115 matching lines @@
 
 // static
 scoped_refptr<base::MessageLoopProxy>
     SimpleResourceLoaderBridge::GetIoThread() {
   if (!EnsureIOThread()) {
     LOG(DFATAL) << "Failed to create IO thread.";
     return NULL;
   }
   return g_io_thread->message_loop_proxy();
 }