Remove async functionality from net::CookiePolicy.

chrome/browser/net/chrome_cookie_policy.cc

-// 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.
 
 #include "chrome/browser/net/chrome_cookie_policy.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/static_cookie_policy.h"
 
 // If we queue up more than this number of completions, then switch from ASK to
 // BLOCK.  More than this number of requests at once seems like it could be a
 // sign of trouble anyways.
 static const size_t kMaxCompletionsPerHost = 10000;

[jochen (gone - plz use gerrit), 2011/03/30 08:15:32]

still needed?

[willchan no longer on Chromium, 2011/04/04 12:29:18]

Done.

 
 // ----------------------------------------------------------------------------
 
 ChromeCookiePolicy::ChromeCookiePolicy(HostContentSettingsMap* map)
-    : host_content_settings_map_(map) {
-  strict_third_party_blocking_ = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kBlockReadingThirdPartyCookies);
-}
+    : host_content_settings_map_(map),
+      strict_third_party_blocking_(
+          CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kBlockReadingThirdPartyCookies)) {}

[jochen (gone - plz use gerrit), 2011/03/30 08:15:32]

I think the closing bracket should go on the next line, wdyt

[willchan no longer on Chromium, 2011/04/04 12:29:18]

There are two varying styles in Chromium and neither is outlawed by the
Google/Chromium style guides. Therefore, it's up to the maintainer of the
file/subsystem. I plan on taking ownership of this code as it's part of
chrome/browser/net, so I'm going to do what I like :)

 
-ChromeCookiePolicy::~ChromeCookiePolicy() {
-  DCHECK(host_completions_map_.empty());
-}
+ChromeCookiePolicy::~ChromeCookiePolicy() {}
 
 int ChromeCookiePolicy::CanGetCookies(const GURL& url,
-                                      const GURL& first_party,
-                                      net::CompletionCallback* callback) {
+                                      const GURL& first_party) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_content_settings_map_->BlockThirdPartyCookies()) {
     net::StaticCookiePolicy policy(strict_third_party_blocking_ ?
         net::StaticCookiePolicy::BLOCK_ALL_THIRD_PARTY_COOKIES :
         net::StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES);
-    int rv = policy.CanGetCookies(url, first_party, NULL);
+    int rv = policy.CanGetCookies(url, first_party);
     if (rv != net::OK)

[jochen (gone - plz use gerrit), 2011/03/30 08:15:32]

maybe also DCHECK for != ERR_IO_PENDING here?

[willchan no longer on Chromium, 2011/04/04 12:29:18]

Done.

       return rv;
   }
 
   int policy = CheckPolicy(url);
   if (policy == net::OK_FOR_SESSION_ONLY)
     policy = net::OK;
-  if (policy != net::ERR_IO_PENDING)
-    return policy;
-
-  DCHECK(callback);
-
-  // If we are currently prompting the user for a 'set-cookie' matching this
-  // host, then we need to defer reading cookies.
-  HostCompletionsMap::iterator it = host_completions_map_.find(url.host());
-  if (it == host_completions_map_.end()) {
-    policy = net::OK;
-  } else if (it->second.size() >= kMaxCompletionsPerHost) {
-    LOG(ERROR) << "Would exceed kMaxCompletionsPerHost";
-    policy = net::ERR_ACCESS_DENIED;
-  } else {
-    it->second.push_back(Completion::ForGetCookies(callback));
-    policy = net::ERR_IO_PENDING;
-  }
+  DCHECK_NE(net::ERR_IO_PENDING, policy);
   return policy;
 }
 
 int ChromeCookiePolicy::CanSetCookie(const GURL& url,
                                      const GURL& first_party,
-                                     const std::string& cookie_line,
-                                     net::CompletionCallback* callback) {
+                                     const std::string& cookie_line) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_content_settings_map_->BlockThirdPartyCookies()) {
     net::StaticCookiePolicy policy(strict_third_party_blocking_ ?
         net::StaticCookiePolicy::BLOCK_ALL_THIRD_PARTY_COOKIES :
         net::StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES);
-    int rv = policy.CanSetCookie(url, first_party, cookie_line, NULL);
+    int rv = policy.CanSetCookie(url, first_party, cookie_line);
     if (rv != net::OK)
       return rv;
   }
 
   int policy = CheckPolicy(url);
-  if (policy != net::ERR_IO_PENDING)
-    return policy;
-
-  DCHECK(callback);
-
-  Completions& completions = host_completions_map_[url.host()];
-  if (completions.size() >= kMaxCompletionsPerHost) {
-    LOG(ERROR) << "Would exceed kMaxCompletionsPerHost";
-    policy = net::ERR_ACCESS_DENIED;
-  } else {
-    completions.push_back(Completion::ForSetCookie(callback));
-    policy = net::ERR_IO_PENDING;
-  }
-
+  DCHECK_NE(net::ERR_IO_PENDING, policy);
   return policy;
 }
 
 int ChromeCookiePolicy::CheckPolicy(const GURL& url) const {
   ContentSetting setting = host_content_settings_map_->GetContentSetting(
       url, CONTENT_SETTINGS_TYPE_COOKIES, "");
   if (setting == CONTENT_SETTING_BLOCK)
     return net::ERR_ACCESS_DENIED;
   if (setting == CONTENT_SETTING_ALLOW)
     return net::OK;
   if (setting == CONTENT_SETTING_SESSION_ONLY)
     return net::OK_FOR_SESSION_ONLY;
   return net::ERR_IO_PENDING;  // Need to prompt.

[jochen (gone - plz use gerrit), 2011/03/30 08:15:32]

NOTREACHED() && return ACCESS DENIED?

[willchan no longer on Chromium, 2011/04/04 12:29:18]

Done.

 }
-