[Devtools] Backend support for setCookie

content/browser/devtools/protocol/network_handler.cc

 // Copyright 2014 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 "content/browser/devtools/protocol/network_handler.h"
 
 #include <stddef.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/strings/stringprintf.h"
@@ skipping 14 matching lines @@
 #include "net/cert/x509_cert_types.h"
 #include "net/cert/x509_certificate.h"
 #include "net/cookies/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 namespace devtools {
 namespace network {
 
+using Response = DevToolsProtocolClient::Response;
 using CookieListCallback = net::CookieStore::GetCookieListCallback;
 
 namespace {
 
 net::URLRequestContext* GetRequestContextOnIO(
     ResourceContext* resource_context,
     net::URLRequestContextGetter* context_getter,
     const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::URLRequestContext* context =
@@ skipping 74 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&DeleteCookieOnIO,
                  base::Unretained(resource_context),
                  base::Unretained(context_getter),
                  url,
                  cookie_name,
                  callback));
 }
 
+void CookieSetOnIO(const base::Closure& callback, bool success) {

[dgozman, 2016/08/09 01:07:25]

Let's send an error over protocol if !success.

[allada, 2016/08/10 02:46:54]

Done.

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      callback);
+}
+
+void SetCookieOnIO(
+    ResourceContext* resource_context,
+    net::URLRequestContextGetter* context_getter,
+    const GURL& url, const std::string& name, const std::string& value,
+    const std::string& domain, const std::string& path, bool secure,
+    bool httpOnly, net::CookieSameSite sameSite, base::Time expires,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::URLRequestContext* request_context =
+      GetRequestContextOnIO(resource_context, context_getter, url);
+
+  bool are_experimental_cookie_features_enabled =
+      request_context->network_delegate()
+        ->AreExperimentalCookieFeaturesEnabled();
+
+  request_context->cookie_store()->SetCookieWithDetailsAsync(
+      url, name, value, domain, path,
+      base::Time(),
+      expires,
+      base::Time(),
+      secure,
+      httpOnly,
+      sameSite,
+      are_experimental_cookie_features_enabled,
+      net::COOKIE_PRIORITY_DEFAULT,
+      base::Bind(&CookieSetOnIO, callback));
+}
+
+void SetCookieOnUI(
+    ResourceContext* resource_context,
+    net::URLRequestContextGetter* context_getter,
+    const GURL& url, const std::string& name, const std::string& value,
+    const std::string& domain, const std::string& path, bool secure,
+    bool httpOnly, net::CookieSameSite sameSite, base::Time expires,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&SetCookieOnIO,
+                 base::Unretained(resource_context),
+                 base::Unretained(context_getter),
+                 url, name, value, domain, path, secure, httpOnly,
+                 sameSite, expires, callback));
+}
+
 class GetCookiesCommand {
  public:
   explicit GetCookiesCommand(
       RenderFrameHostImpl* frame_host,
       const CookieListCallback& callback)
       : callback_(callback),
         request_count_(0) {
     CookieListCallback got_cookies_callback = base::Bind(
         &GetCookiesCommand::GotCookiesForURL, base::Unretained(this));
 
@@ skipping 74 matching lines @@
 
 Response NetworkHandler::ClearBrowserCookies() {
   if (host_)
     GetContentClient()->browser()->ClearCookies(host_);
   return Response::OK();
 }
 
 Response NetworkHandler::GetCookies(DevToolsCommandId command_id) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
+
   new GetCookiesCommand(
       host_,
       base::Bind(&NetworkHandler::SendGetCookiesResponse,
                  weak_factory_.GetWeakPtr(),
                  command_id));
   return Response::OK();
 }
 
+Response NetworkHandler::SetCookie(DevToolsCommandId command_id,
+    const std::string& url, const std::string& name,
+    const std::string& value, const std::string* domain,
+    const std::string* path, bool* secure, bool* httpOnly,
+    const std::string* sameSite, double* expires) {
+  if (!host_)
+    return Response::InternalError("Could not connect to view");
+
+  net::CookieSameSite sameSiteEnum = net::CookieSameSite::DEFAULT_MODE;
+  if (sameSite && *sameSite == "lax")

[dgozman, 2016/08/09 01:07:24]

There are generated constants for all enums in protocol.

[allada, 2016/08/10 02:46:54]

Done.

+    sameSiteEnum = net::CookieSameSite::LAX_MODE;
+  else if (sameSite && *sameSite == "strict")
+    sameSiteEnum = net::CookieSameSite::STRICT_MODE;
+
+  base::Time expirationDate;
+  if (expires)
+    expirationDate = (*expires == 0)
+            ? base::Time::UnixEpoch()
+            : base::Time::FromDoubleT(*expires);
+
+  SetCookieOnUI(
+      host_->GetSiteInstance()->GetBrowserContext()->GetResourceContext(),
+      host_->GetProcess()->GetStoragePartition()->GetURLRequestContext(),
+      GURL(url), name, value,
+      domain ? *domain : std::string(), path ? *path : std::string(),
+      secure ? *secure : false, httpOnly ? *httpOnly : false,
+      sameSiteEnum, expirationDate,
+      base::Bind(&NetworkHandler::SendSetCookieResponse,
+                 weak_factory_.GetWeakPtr(),
+                 command_id));
+  return Response::OK();
+}
+
+void NetworkHandler::SendSetCookieResponse(DevToolsCommandId command_id) {
+  client_->SendSetCookieResponse(command_id,
+      SetCookieResponse::Create());
+}
+
 void NetworkHandler::SendGetCookiesResponse(
     DevToolsCommandId command_id,
     const net::CookieList& cookie_list) {
   std::vector<scoped_refptr<Cookie>> cookies;
   for (size_t i = 0; i < cookie_list.size(); ++i) {
     const net::CanonicalCookie& cookie = cookie_list[i];
     scoped_refptr<Cookie> devtools_cookie = Cookie::Create()
          ->set_name(cookie.Name())
          ->set_value(cookie.Value())
          ->set_domain(cookie.Domain())
@@ skipping 99 matching lines @@
     return Response::InternalError("Could not connect to view");
   WebContents* web_contents = WebContents::FromRenderFrameHost(host_);
   web_contents->GetDelegate()->ShowCertificateViewerInDevTools(
       web_contents, certificate_id);
   return Response::OK();
 }
 
 }  // namespace network
 }  // namespace devtools
 }  // namespace content