Fix FullTabModeIE_ChromeFrameDeleteCookieTest. The problem was that a domain...

chrome/browser/automation/url_request_automation_job.cc

 // Copyright (c) 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/url_request_automation_job.h"
 
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "chrome/browser/automation/automation_resource_message_filter.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 31 matching lines @@
 };
 
 int URLRequestAutomationJob::instance_count_ = 0;
 bool URLRequestAutomationJob::is_protocol_factory_registered_ = false;
 
 URLRequest::ProtocolFactory* URLRequestAutomationJob::old_http_factory_
     = NULL;
 URLRequest::ProtocolFactory* URLRequestAutomationJob::old_https_factory_
     = NULL;
 
+namespace {
+
+// Returns true if the cookie passed in exists in the list of cookies
+// parsed from the HTTP response header.
+bool IsParsedCookiePresentInCookieHeader(
+    const net::CookieMonster::ParsedCookie& parsed_cookie,
+    const std::vector<std::string>& header_cookies) {
+  for (size_t i = 0; i < header_cookies.size(); ++i) {
+    net::CookieMonster::ParsedCookie parsed_header_cookie(header_cookies[i]);
+    if (parsed_header_cookie.Name() == parsed_cookie.Name())
+      return true;
+  }
+
+  return false;
+}
+
+}  // end namespace
+
 URLRequestAutomationJob::URLRequestAutomationJob(URLRequest* request, int tab,
     int request_id, AutomationResourceMessageFilter* filter)
     : URLRequestJob(request),
       tab_(tab),
       message_filter_(filter),
       pending_buf_size_(0),
       redirect_status_(0),
       request_id_(request_id) {
   DLOG(INFO) << "URLRequestAutomationJob create. Count: " << ++instance_count_;
   DCHECK(message_filter_ != NULL);
@@ skipping 222 matching lines @@
                                                    options);
       }
     }
   }
 
   if (ctx && ctx->cookie_store() && !response.persistent_cookies.empty() &&
       ctx->cookie_policy()->CanSetCookie(
           url_for_cookies, request_->first_party_for_cookies())) {
     StringTokenizer cookie_parser(response.persistent_cookies, ";");
 
+    std::vector<net::CookieMonster::CanonicalCookie> existing_cookies;
+    net::CookieMonster* monster = ctx->cookie_store()->GetCookieMonster();
+    DCHECK(monster);
+    if (monster) {
+      monster->GetRawCookies(url_for_cookies, &existing_cookies);
+    }
+
     while (cookie_parser.GetNext()) {
       std::string cookie_string = cookie_parser.token();
       // Only allow cookies with valid name value pairs.
       if (cookie_string.find('=') != std::string::npos) {
         TrimWhitespace(cookie_string, TRIM_ALL, &cookie_string);
         // Ignore duplicate cookies, i.e. cookies passed in from the host
         // browser which also exist in the response header.
-        if (!IsCookiePresentInCookieHeader(cookie_string,
-                                           response_cookies)) {
-            net::CookieOptions options;
-            ctx->cookie_store()->SetCookieWithOptions(url_for_cookies,
-                                                      cookie_string,
-                                                      options);
+        net::CookieMonster::ParsedCookie parsed_cookie(cookie_string);
+        std::vector<net::CookieMonster::CanonicalCookie>::const_iterator i;
+        for (i = existing_cookies.begin(); i != existing_cookies.end(); ++i) {
+          if ((*i).Name() == parsed_cookie.Name())
+            break;
+        }
+
+        if (i == existing_cookies.end() &&
+            !IsParsedCookiePresentInCookieHeader(parsed_cookie,
+                                                 response_cookies)) {
+          net::CookieOptions options;
+          ctx->cookie_store()->SetCookieWithOptions(url_for_cookies,
+                                                    cookie_string,
+                                                    options);
         }
       }
     }
   }
 
   NotifyHeadersComplete();
 }
 
 void URLRequestAutomationJob::OnDataAvailable(
     int tab, int id, const std::string& bytes) {
@@ skipping 125 matching lines @@
 }
 
 void URLRequestAutomationJob::DisconnectFromMessageFilter() {
   if (message_filter_) {
     message_filter_->UnRegisterRequest(this);
     message_filter_ = NULL;
   }
 }
 
 bool URLRequestAutomationJob::IsCookiePresentInCookieHeader(
-    const std::string& cookie_line,
+    const std::string& cookie_name,
     const std::vector<std::string>& header_cookies) {
-  net::CookieMonster::ParsedCookie parsed_current_cookie(cookie_line);
-  for (size_t index = 0; index < header_cookies.size(); index++) {
-    net::CookieMonster::ParsedCookie parsed_header_cookie(
-        header_cookies[index]);
-
-    if (parsed_header_cookie.Name() == parsed_current_cookie.Name())
-      return true;
-  }
-
-  return false;
+  net::CookieMonster::ParsedCookie parsed_cookie(cookie_name);
+  return IsParsedCookiePresentInCookieHeader(parsed_cookie, header_cookies);
 }
-