ChromeFrame cookie requests would incorrectly get routed to the first host br...

chrome/browser/automation/automation_profile_impl.cc

 // Copyright (c) 2006-2009 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/automation/automation_profile_impl.h"
 
 #include <map>
 
 #include "chrome/browser/automation/automation_resource_message_filter.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 79 matching lines @@
                             const std::string& cookie_name) {
     NOTREACHED() << "Should not get called for an automation profile";
   }
 
   virtual net::CookieMonster* GetCookieMonster() {
     NOTREACHED() << "Should not get called for an automation profile";
     return NULL;
   }
 
  protected:
-  void SendIPCMessageOnIOThread(IPC::Message* m) {
-    if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-      automation_client_->Send(m);
-    } else {
-      Task* task = NewRunnableMethod(this,
-          &AutomationCookieStore::SendIPCMessageOnIOThread, m);
-      ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, task);
-    }
-  }
-
   net::CookieStore* original_cookie_store_;
   scoped_refptr<AutomationResourceMessageFilter> automation_client_;
   int tab_handle_;
   std::string cookie_string_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutomationCookieStore);
 };
 
 // CookiePolicy specialization for automation specific cookie policies.
 class AutomationCookiePolicy : public net::CookiePolicy {
  public:
   AutomationCookiePolicy(AutomationResourceMessageFilter* automation_client,
                          int tab_handle, net::CookieStore* cookie_store)
       : automation_client_(automation_client),
         tab_handle_(tab_handle),
         cookie_store_(cookie_store) {}
 
   virtual int CanGetCookies(const GURL& url,
                             const GURL& first_party_for_cookies,
                             net::CompletionCallback* callback) {
     DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
-    if (automation_client_.get()) {
-      automation_client_->GetCookiesForUrl(tab_handle_, url, callback,
-                                           cookie_store_.get());
-      return net::ERR_IO_PENDING;
-    }
-    return net::ERR_ACCESS_DENIED;
+    AutomationResourceMessageFilter::GetCookiesForUrl(tab_handle_, url,
+                                                      callback,
+                                                      cookie_store_.get());
+    return net::ERR_IO_PENDING;
   }
 
   virtual int CanSetCookie(const GURL& url,
                            const GURL& first_party_for_cookies,
                            const std::string& cookie_line,
                            net::CompletionCallback* callback) {
-    if (automation_client_.get()) {
-      automation_client_->Send(new AutomationMsg_SetCookieAsync(0,
-          tab_handle_, url, cookie_line));
-    }
-    return net::ERR_ACCESS_DENIED;
+    AutomationResourceMessageFilter::SetCookiesForUrl(tab_handle_, url,
+                                                      cookie_line,
+                                                      callback);
+    return net::ERR_IO_PENDING;
   }
 
  private:
   scoped_refptr<AutomationResourceMessageFilter> automation_client_;
   int tab_handle_;
   scoped_refptr<net::CookieStore> cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationCookiePolicy);
 };
 
@@ skipping 47 matching lines @@
   ChromeURLRequestContextGetter* request_context =
       new ChromeURLRequestContextGetter(
           NULL,  // Don't register an observer on PrefService.
           new Factory(original_context, profile, automation_client,
                       tab_handle));
   return request_context;
 }
 
 }  // namespace AutomationRequestContext