Remove async functionality from net::CookiePolicy.

This lets us stop refcounting URLRequestHttpJob.

BUG=none
TEST=none


Review URL: http://codereview.chromium.org/6749044

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@80660 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 20 insertions, 64 deletions

diff --git a/net/websockets/websocket_job.cc b/net/websockets/websocket_job.cc
index 8379523..7a5e030 100644
--- a/net/websockets/websocket_job.cc
+++ b/net/websockets/websocket_job.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -68,10 +68,6 @@ WebSocketJob::WebSocketJob(SocketStream::Delegate* delegate)
       handshake_response_(new WebSocketHandshakeResponseHandler),
       handshake_request_sent_(0),
       response_cookies_save_index_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_get_cookies_callback_(
-          this, &WebSocketJob::OnCanGetCookiesCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_set_cookie_callback_(
-          this, &WebSocketJob::OnCanSetCookieCompleted)),
       send_frame_handler_(new WebSocketFrameHandler),
       receive_frame_handler_(new WebSocketFrameHandler) {
 }
@@ -281,18 +277,14 @@ bool WebSocketJob::SendHandshakeRequest(const char* data, int len) {
 }
 
 void WebSocketJob::AddCookieHeaderAndSend() {
-  AddRef();  // Balanced in OnCanGetCookiesCompleted
-
   int policy = OK;
   if (socket_->context()->cookie_policy()) {
     GURL url_for_cookies = GetURLForCookies();
     policy = socket_->context()->cookie_policy()->CanGetCookies(
         url_for_cookies,
-        url_for_cookies,
-        &can_get_cookies_callback_);
-    if (policy == ERR_IO_PENDING)
-      return;  // Wait for completion callback
+        url_for_cookies);
   }
+  DCHECK_NE(ERR_IO_PENDING, policy);
   OnCanGetCookiesCompleted(policy);
 }
 
@@ -322,7 +314,6 @@ void WebSocketJob::OnCanGetCookiesCompleted(int policy) {
     socket_->SendData(handshake_request.data(),
                       handshake_request.size());
   }
-  Release();  // Balance AddRef taken in AddCookieHeaderAndSend
 }
 
 void WebSocketJob::OnSentHandshakeRequest(
@@ -414,20 +405,16 @@ void WebSocketJob::SaveNextCookie() {
     return;
   }
 
-  AddRef();  // Balanced in OnCanSetCookieCompleted
-
   int policy = OK;
   if (socket_->context()->cookie_policy()) {
     GURL url_for_cookies = GetURLForCookies();
     policy = socket_->context()->cookie_policy()->CanSetCookie(
         url_for_cookies,
         url_for_cookies,
-        response_cookies_[response_cookies_save_index_],
-        &can_set_cookie_callback_);
-    if (policy == ERR_IO_PENDING)
-      return;  // Wait for completion callback
+        response_cookies_[response_cookies_save_index_]);
   }
 
+  DCHECK_NE(ERR_IO_PENDING, policy);
   OnCanSetCookieCompleted(policy);
 }
 
@@ -447,7 +434,6 @@ void WebSocketJob::OnCanSetCookieCompleted(int policy) {
     response_cookies_save_index_++;
     SaveNextCookie();
   }
-  Release();  // Balance AddRef taken in SaveNextCookie
 }
 
 GURL WebSocketJob::GetURLForCookies() const {
diff --git a/net/websockets/websocket_job.h b/net/websockets/websocket_job.h
index d9a6e71..1de1c1d 100644
--- a/net/websockets/websocket_job.h
+++ b/net/websockets/websocket_job.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -108,9 +108,6 @@ class WebSocketJob : public SocketStreamJob, public SocketStream::Delegate {
   std::vector<std::string> response_cookies_;
   size_t response_cookies_save_index_;
 
-  CompletionCallbackImpl<WebSocketJob> can_get_cookies_callback_;
-  CompletionCallbackImpl<WebSocketJob> can_set_cookie_callback_;
-
   scoped_ptr<WebSocketFrameHandler> send_frame_handler_;
   scoped_refptr<DrainableIOBuffer> current_buffer_;
   scoped_ptr<WebSocketFrameHandler> receive_frame_handler_;
diff --git a/net/websockets/websocket_job_unittest.cc b/net/websockets/websocket_job_unittest.cc
index a6f333a..a0ae1d4 100644
--- a/net/websockets/websocket_job_unittest.cc
+++ b/net/websockets/websocket_job_unittest.cc
@@ -122,59 +122,32 @@ class MockCookieStore : public CookieStore {
   std::vector<Entry> entries_;
 };
 
-class MockCookiePolicy : public CookiePolicy,
-                         public base::RefCountedThreadSafe<MockCookiePolicy> {
+class MockCookiePolicy : public CookiePolicy {
  public:
-  MockCookiePolicy() : allow_all_cookies_(true), callback_(NULL) {}
+  MockCookiePolicy() : allow_all_cookies_(true) {}
+  virtual ~MockCookiePolicy() {}
 
   void set_allow_all_cookies(bool allow_all_cookies) {
     allow_all_cookies_ = allow_all_cookies;
   }
 
   virtual int CanGetCookies(const GURL& url,
-                            const GURL& first_party_for_cookies,
-                            CompletionCallback* callback) {
-    DCHECK(!callback_);
-    callback_ = callback;
-    MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &MockCookiePolicy::OnCanGetCookies));
-    return ERR_IO_PENDING;
+                            const GURL& first_party_for_cookies) const {
+    if (allow_all_cookies_)
+      return OK;
+    return ERR_ACCESS_DENIED;
   }
 
   virtual int CanSetCookie(const GURL& url,
                            const GURL& first_party_for_cookies,
-                           const std::string& cookie_line,
-                           CompletionCallback* callback) {
-    DCHECK(!callback_);
-    callback_ = callback;
-    MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &MockCookiePolicy::OnCanSetCookie));
-    return ERR_IO_PENDING;
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<MockCookiePolicy>;
-  virtual ~MockCookiePolicy() {}
-
-  void OnCanGetCookies() {
-    CompletionCallback* callback = callback_;
-    callback_ = NULL;
+                           const std::string& cookie_line) const {
     if (allow_all_cookies_)
-      callback->Run(OK);
-    else
-      callback->Run(ERR_ACCESS_DENIED);
-  }
-  void OnCanSetCookie() {
-    CompletionCallback* callback = callback_;
-    callback_ = NULL;
-    if (allow_all_cookies_)
-      callback->Run(OK);
-    else
-      callback->Run(ERR_ACCESS_DENIED);
+      return OK;
+    return ERR_ACCESS_DENIED;
   }
 
+ private:
   bool allow_all_cookies_;
-  CompletionCallback* callback_;
 };
 
 class MockURLRequestContext : public URLRequestContext {
@@ -194,13 +167,13 @@ class WebSocketJobTest : public PlatformTest {
  public:
   virtual void SetUp() {
     cookie_store_ = new MockCookieStore;
-    cookie_policy_ = new MockCookiePolicy;
+    cookie_policy_.reset(new MockCookiePolicy);
     context_ = new MockURLRequestContext(
         cookie_store_.get(), cookie_policy_.get());
   }
   virtual void TearDown() {
     cookie_store_ = NULL;
-    cookie_policy_ = NULL;
+    cookie_policy_.reset();
     context_ = NULL;
     websocket_ = NULL;
     socket_ = NULL;
@@ -238,7 +211,7 @@ class WebSocketJobTest : public PlatformTest {
   }
 
   scoped_refptr<MockCookieStore> cookie_store_;
-  scoped_refptr<MockCookiePolicy> cookie_policy_;
+  scoped_ptr<MockCookiePolicy> cookie_policy_;
   scoped_refptr<MockURLRequestContext> context_;
   scoped_refptr<WebSocketJob> websocket_;
   scoped_refptr<MockSocketStream> socket_;