Remove async functionality from net::CookiePolicy.

net/websockets/websocket_job_unittest.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.
 
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 104 matching lines @@
 
   const std::vector<Entry>& entries() const { return entries_; }
 
  private:
   friend class base::RefCountedThreadSafe<MockCookieStore>;
   virtual ~MockCookieStore() {}
 
   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;
+                           const std::string& cookie_line) const {
+    if (allow_all_cookies_)
+      return OK;
+    return ERR_ACCESS_DENIED;
   }
 
  private:
-  friend class base::RefCountedThreadSafe<MockCookiePolicy>;
-  virtual ~MockCookiePolicy() {}
-
-  void OnCanGetCookies() {
-    CompletionCallback* callback = callback_;
-    callback_ = NULL;
-    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);
-  }
-
   bool allow_all_cookies_;
-  CompletionCallback* callback_;
 };
 
 class MockURLRequestContext : public URLRequestContext {
  public:
   MockURLRequestContext(CookieStore* cookie_store,
                         CookiePolicy* cookie_policy) {
     set_cookie_store(cookie_store);
     set_cookie_policy(cookie_policy);
   }
 
  private:
   friend class base::RefCountedThreadSafe<MockURLRequestContext>;
   virtual ~MockURLRequestContext() {}
 };
 
 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;
   }
  protected:
   void InitWebSocketJob(const GURL& url, MockSocketStreamDelegate* delegate) {
     websocket_ = new WebSocketJob(delegate);
     socket_ = new MockSocketStream(url, websocket_.get());
     websocket_->InitSocketStream(socket_.get());
     websocket_->set_context(context_.get());
@@ skipping 17 matching lines @@
     if (websocket_->socket_) {
       websocket_->socket_->DetachDelegate();
       WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_);
     }
     websocket_->state_ = WebSocketJob::CLOSED;
     websocket_->delegate_ = NULL;
     websocket_->socket_ = NULL;
   }
 
   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_;
 };
 
 TEST_F(WebSocketJobTest, SimpleHandshake) {
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate);
 
@@ skipping 263 matching lines @@
   EXPECT_EQ(2U, cookie_store_->entries().size());
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
   EXPECT_EQ("CR-test=1", cookie_store_->entries()[0].cookie_line);
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[1].url);
   EXPECT_EQ("CR-test-httponly=1", cookie_store_->entries()[1].cookie_line);
 
   CloseWebSocketJob();
 }
 
 }  // namespace net