Pass in the HostContentSettingsMap to the CookieModalDialog so IsValid can ma...

chrome/browser/net/chrome_cookie_policy.cc

 // Copyright (c) 2010 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/string_util.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/cookie_prompt_modal_dialog_delegate.h"
@@ skipping 13 matching lines @@
 // may have several prompts pending.
 class ChromeCookiePolicy::PromptDelegate
     : public CookiePromptModalDialogDelegate {
  public:
   PromptDelegate(ChromeCookiePolicy* cookie_policy, const std::string& host)
       : cookie_policy_(cookie_policy),
         host_(host) {
   }
 
   // CookiesPromptViewDelegate methods:
-  virtual void AllowSiteData(bool remember, bool session_expire);
-  virtual void BlockSiteData(bool remember);
+  virtual void AllowSiteData(bool session_expire);
+  virtual void BlockSiteData();
 
  private:
-  void NotifyDone(int policy, bool remember);
+  void NotifyDone(int policy);
 
   scoped_refptr<ChromeCookiePolicy> cookie_policy_;
   std::string host_;
 };
 
-void ChromeCookiePolicy::PromptDelegate::AllowSiteData(bool remember,
-                                                       bool session_expire) {
+void ChromeCookiePolicy::PromptDelegate::AllowSiteData(bool session_expire) {
   int policy = net::OK;
   if (session_expire)
     policy = net::OK_FOR_SESSION_ONLY;
-  NotifyDone(policy, remember);
+  NotifyDone(policy);
 }
 
-void ChromeCookiePolicy::PromptDelegate::BlockSiteData(bool remember) {
-  NotifyDone(net::ERR_ACCESS_DENIED, remember);
+void ChromeCookiePolicy::PromptDelegate::BlockSiteData() {
+  NotifyDone(net::ERR_ACCESS_DENIED);
 }
 
-void ChromeCookiePolicy::PromptDelegate::NotifyDone(int policy, bool remember) {
-  cookie_policy_->DidPromptForSetCookie(host_, policy, remember);
+void ChromeCookiePolicy::PromptDelegate::NotifyDone(int policy) {
+  cookie_policy_->DidPromptForSetCookie(host_, policy);
   delete this;
 }
 
 // ----------------------------------------------------------------------------
 
 ChromeCookiePolicy::ChromeCookiePolicy(HostContentSettingsMap* map)
     : host_content_settings_map_(map) {
 }
 
 ChromeCookiePolicy::~ChromeCookiePolicy() {
@@ skipping 89 matching lines @@
                           cookie_line));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   const std::string& host = url.host();
 
   // The policy may have changed (due to the "remember" option)
   int policy = CheckPolicy(url);
   if (policy != net::ERR_IO_PENDING) {
-    DidPromptForSetCookie(host, policy, false);
+    DidPromptForSetCookie(host, policy);
     return;
   }
 
   // Show the prompt on top of the current tab.
   Browser* browser = BrowserList::GetLastActive();
   if (!browser || !browser->GetSelectedTabContents()) {
-    DidPromptForSetCookie(host, net::ERR_ACCESS_DENIED, false);
+    DidPromptForSetCookie(host, net::ERR_ACCESS_DENIED);
     return;
   }
 
 #if defined(OS_WIN)
-  RunCookiePrompt(browser->GetSelectedTabContents(), url, cookie_line,
+  RunCookiePrompt(browser->GetSelectedTabContents(),
+                  host_content_settings_map_, url, cookie_line,
                   new PromptDelegate(this, host));
 #else
   // TODO(darin): Enable prompting for other ports.
-  DidPromptForSetCookie(host, net::ERR_ACCESS_DENIED, false);
+  DidPromptForSetCookie(host, net::ERR_ACCESS_DENIED);
 #endif
 }
 
 void ChromeCookiePolicy::DidPromptForSetCookie(const std::string& host,
-                                               int policy, bool remember) {
+                                               int policy) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    // Process the remember flag immediately.
-    if (remember) {
-      ContentSetting content_setting = CONTENT_SETTING_BLOCK;
-      if (policy == net::OK || policy == net::OK_FOR_SESSION_ONLY)
-        content_setting = CONTENT_SETTING_ALLOW;
-      host_content_settings_map_->SetContentSetting(
-          host, CONTENT_SETTINGS_TYPE_COOKIES, content_setting);
-    }
-
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(this, &ChromeCookiePolicy::DidPromptForSetCookie,
-                          host, policy, remember));
+                          host, policy));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   // Notify all callbacks, starting with the first until we hit another that
   // is for a 'set-cookie'.
   HostCompletionsMap::iterator it = host_completions_map_.find(host);
   CHECK(it != host_completions_map_.end());
 
@@ skipping 13 matching lines @@
     callbacks.push_back(completions[i].callback());
   }
   completions.erase(completions.begin(), completions.begin() + i);
 
   if (completions.empty())
     host_completions_map_.erase(it);
 
   for (size_t j = 0; j < callbacks.size(); ++j)
     callbacks[j]->Run(policy);
 }