[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;
+using SetCookieCallback = net::CookieStore::SetCookiesCallback;
 
 namespace {
 
 net::URLRequestContext* GetRequestContextOnIO(
     ResourceContext* resource_context,
     net::URLRequestContextGetter* context_getter,
     const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::URLRequestContext* context =
       GetContentClient()->browser()->OverrideRequestContextForURL(
@@ skipping 73 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&DeleteCookieOnIO,
                  base::Unretained(resource_context),
                  base::Unretained(context_getter),
                  url,
                  cookie_name,
                  callback));
 }
 
+void CookieSetOnIO(const SetCookieCallback& callback, bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(callback, success));
+}
+
+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 http_only,
+    net::CookieSameSite same_site,
+    base::Time expires,
+    const SetCookieCallback& 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,
+      http_only,
+      same_site,
+      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 http_only,
+    net::CookieSameSite same_site,
+    base::Time expires,
+    const SetCookieCallback& 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, http_only,
+                 same_site, 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 82 matching lines @@
   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* http_only,
+    const std::string* same_site,
+    double* expires) {
+  if (!host_)
+    return Response::InternalError("Could not connect to view");
+
+  net::CookieSameSite same_site_enum = net::CookieSameSite::DEFAULT_MODE;
+  if (same_site && *same_site == kCookieSameSiteLax)
+    same_site_enum = net::CookieSameSite::LAX_MODE;
+  else if (same_site && *same_site == kCookieSameSiteStrict)
+    same_site_enum = net::CookieSameSite::STRICT_MODE;
+
+  base::Time expiration_date;
+  if (expires)
+    expiration_date = (*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, http_only ? *http_only : false,
+      same_site_enum, expiration_date,
+      base::Bind(&NetworkHandler::SendSetCookieResponse,
+                 weak_factory_.GetWeakPtr(),
+                 command_id));
+  return Response::OK();
+}
+
+void NetworkHandler::SendSetCookieResponse(DevToolsCommandId command_id,
+    bool success) {
+  client_->SendSetCookieResponse(command_id,
+      SetCookieResponse::Create()->set_success(success));
+}
+
 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())
          ->set_path(cookie.Path())
          ->set_expires(cookie.ExpiryDate().ToDoubleT() * 1000)
          ->set_size(cookie.Name().length() + cookie.Value().length())
          ->set_http_only(cookie.IsHttpOnly())
          ->set_secure(cookie.IsSecure())
          ->set_session(!cookie.IsPersistent());
 
     switch (cookie.SameSite()) {
       case net::CookieSameSite::STRICT_MODE:
-        devtools_cookie->set_same_site(cookie::kSameSiteStrict);
+        devtools_cookie->set_same_site(kCookieSameSiteStrict);
         break;
       case net::CookieSameSite::LAX_MODE:
-        devtools_cookie->set_same_site(cookie::kSameSiteLax);
+        devtools_cookie->set_same_site(kCookieSameSiteLax);
         break;
       case net::CookieSameSite::NO_RESTRICTION:
         break;
     }
     cookies.push_back(devtools_cookie);
   }
   client_->SendGetCookiesResponse(command_id,
       GetCookiesResponse::Create()->set_cookies(cookies));
 }
 
@@ skipping 76 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