Adding Priority field to cookies.

chrome/browser/automation/automation_util.cc

 // Copyright (c) 2012 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_util.h"
 
 #include <string>
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/automation_id.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/view_type_utils.h"
 #include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/login_display_host.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
@@ skipping 74 matching lines @@
     const std::string& original_domain,
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     base::WaitableEvent* event,
     bool* success) {
   net::CookieMonster* cookie_monster =
       context_getter->GetURLRequestContext()->cookie_store()->
       GetCookieMonster();
   cookie_monster->SetCookieWithDetailsAsync(
       url, cookie.Name(), cookie.Value(), original_domain,
       cookie.Path(), cookie.ExpiryDate(), cookie.IsSecure(),
-      cookie.IsHttpOnly(),
+      cookie.IsHttpOnly(), cookie.Priority(),
       base::Bind(&SetCookieCallback, event, success));
 }
 
 void DeleteCookieCallback(base::WaitableEvent* event) {
   event->Signal();
 }
 
 void DeleteCookieOnIOThread(
     const GURL& url,
     const std::string& name,
@@ skipping 172 matching lines @@
     const net::CanonicalCookie& cookie = cookie_list[i];
     DictionaryValue* cookie_dict = new DictionaryValue();
     cookie_dict->SetString("name", cookie.Name());
     cookie_dict->SetString("value", cookie.Value());
     cookie_dict->SetString("path", cookie.Path());
     cookie_dict->SetString("domain", cookie.Domain());
     cookie_dict->SetBoolean("secure", cookie.IsSecure());
     cookie_dict->SetBoolean("http_only", cookie.IsHttpOnly());
     if (cookie.IsPersistent())
       cookie_dict->SetDouble("expiry", cookie.ExpiryDate().ToDoubleT());
+    if (cookie.Priority() != net::COOKIE_PRIORITY_DEFAULT) {
+      cookie_dict->SetString("priority",
+                             net::CookiePriorityToString(cookie.Priority()));
+    }
     list->Append(cookie_dict);
   }
   DictionaryValue dict;
   dict.Set("cookies", list);
   reply.SendSuccess(&dict);
 }
 
 void DeleteCookieJSON(AutomationProvider* provider,
                       DictionaryValue* args,
                       IPC::Message* reply_message) {
@@ skipping 37 matching lines @@
   if (!args->GetDictionary("cookie", &cookie_dict)) {
     reply.SendError("'cookie' missing or invalid");
     return;
   }
   std::string name, value;
   std::string domain;
   std::string path = "/";
   bool secure = false;
   double expiry = 0;
   bool http_only = false;
+  net::CookiePriority priority = net::COOKIE_PRIORITY_DEFAULT;
+
   if (!cookie_dict->GetString("name", &name)) {
     reply.SendError("'name' missing or invalid");
     return;
   }
   if (!cookie_dict->GetString("value", &value)) {
     reply.SendError("'value' missing or invalid");
     return;
   }
   if (cookie_dict->HasKey("domain") &&
       !cookie_dict->GetString("domain", &domain)) {
@@ skipping 14 matching lines @@
     if (!cookie_dict->GetDouble("expiry", &expiry)) {
       reply.SendError("optional 'expiry' invalid");
       return;
     }
   }
   if (cookie_dict->HasKey("http_only") &&
       !cookie_dict->GetBoolean("http_only", &http_only)) {
     reply.SendError("optional 'http_only' invalid");
     return;
   }
+  if (cookie_dict->HasKey("priority")) {
+    std::string priority_string;
+    if (!cookie_dict->GetString("priority", &priority_string)) {
+      reply.SendError("optional 'priority' invalid");
+      return;
+    }
+    priority = net::StringToCookiePriority(priority_string);
+  }
 
   scoped_ptr<net::CanonicalCookie> cookie(
       net::CanonicalCookie::Create(
           GURL(url), name, value, domain, path, base::Time(),
-          base::Time::FromDoubleT(expiry), secure, http_only));
+          base::Time::FromDoubleT(expiry), secure, http_only, priority));
   if (!cookie.get()) {
     reply.SendError("given 'cookie' parameters are invalid");
     return;
   }
 
   // Since we may be on the UI thread don't call GetURLRequestContext().
   scoped_refptr<net::URLRequestContextGetter> context_getter =
       provider->profile()->GetRequestContext();
 
   base::WaitableEvent event(true /* manual reset */,
@@ skipping 185 matching lines @@
       const extensions::Extension* extension;
       return GetExtensionForId(id, profile, &extension);
     }
     default:
       break;
   }
   return false;
 }
 
 }  // namespace automation_util