devtools: Split Network.getCookies into Network.get{All,}Cookies

This patch splits the Network.getCookies command into
Network.getCookies, which returns the cookies for the current URL and
Network.getAllCookies, which returns all the cookies in the cookie jar.

BUG=668932,166637

Review-Url: https://codereview.chromium.org/2568503002
Cr-Commit-Position: refs/heads/master@{#438198}

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

@@ -1487,9 +1487,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, SetAndGetCookies) {
   EXPECT_EQ("mendacious", value);
 
   // Then get all the cookies in the cookie jar.
-  command_params.reset(new base::DictionaryValue());
-  command_params->SetBoolean("global", true);
-  SendCommand("Network.getCookies", std::move(command_params), true);
+  SendCommand("Network.getAllCookies", nullptr, true);
 
   EXPECT_TRUE(result_->HasKey("cookies"));
   EXPECT_TRUE(result_->GetList("cookies", &cookies));

content/browser/devtools/protocol/network_handler.cc

@@ -29,6 +29,7 @@ namespace protocol {
 namespace {
 
 using GetCookiesCallback = protocol::Network::Backend::GetCookiesCallback;
+using GetAllCookiesCallback = protocol::Network::Backend::GetAllCookiesCallback;
 using SetCookieCallback = protocol::Network::Backend::SetCookieCallback;
 using DeleteCookieCallback = protocol::Network::Backend::DeleteCookieCallback;
 
@@ -145,63 +146,19 @@ void SetCookieOnIO(
       base::Bind(&CookieSetOnIO, base::Passed(std::move(callback))));
 }
 
-class GetCookiesCommand {
+template <typename Callback>
+class GetCookiesCommandBase {
  public:
-  GetCookiesCommand(
-      RenderFrameHostImpl* frame_host,
-      bool global,
-      std::unique_ptr<GetCookiesCallback> callback)
-      : callback_(std::move(callback)),
-        request_count_(0) {
-    net::CookieStore::GetCookieListCallback got_cookies_callback = base::Bind(
-        &GetCookiesCommand::GotCookiesForURL, base::Unretained(this));
-
-    if (global) {
-      request_count_ = 1;
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-          &GetAllCookiesOnIO,
-          base::Unretained(frame_host->GetSiteInstance()->GetBrowserContext()->
-                           GetResourceContext()),
-          base::Unretained(frame_host->GetProcess()->GetStoragePartition()->
-                           GetURLRequestContext()),
-          got_cookies_callback));
-      return;
-    }
-
-    std::queue<FrameTreeNode*> queue;
-    queue.push(frame_host->frame_tree_node());
-    while (!queue.empty()) {
-      FrameTreeNode* node = queue.front();
-      queue.pop();
-
-      // Only traverse nodes with the same local root.
-      if (node->current_frame_host()->IsCrossProcessSubframe())
-        continue;
-      ++request_count_;
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-          &GetCookiesForURLOnIO,
-          base::Unretained(frame_host->GetSiteInstance()->GetBrowserContext()->
-                           GetResourceContext()),
-          base::Unretained(frame_host->GetProcess()->GetStoragePartition()->
-                           GetURLRequestContext()),
-          node->current_url(),
-          got_cookies_callback));
-
-      for (size_t i = 0; i < node->child_count(); ++i)
-        queue.push(node->child_at(i));
-    }
-  }
+  GetCookiesCommandBase(std::unique_ptr<Callback> callback)
+      : callback_(std::move(callback)), request_count_(0) {}
 
- private:
+ protected:
   void GotCookiesForURL(const net::CookieList& cookie_list) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     for (const net::CanonicalCookie& cookie : cookie_list) {
       std::string key = base::StringPrintf(
-          "%s::%s::%s::%d",
-          cookie.Name().c_str(),
-          cookie.Domain().c_str(),
-          cookie.Path().c_str(),
-          cookie.IsSecure());
+          "%s::%s::%s::%d", cookie.Name().c_str(), cookie.Domain().c_str(),
+          cookie.Path().c_str(), cookie.IsSecure());
       cookies_[key] = cookie;
     }
     --request_count_;
@@ -244,11 +201,69 @@ class GetCookiesCommand {
     callback_->sendSuccess(std::move(cookies));
   }
 
-  std::unique_ptr<GetCookiesCallback> callback_;
+  std::unique_ptr<Callback> callback_;
   int request_count_;
   base::hash_map<std::string, net::CanonicalCookie> cookies_;
 };
 
+class GetCookiesCommand : public GetCookiesCommandBase<GetCookiesCallback> {
+ public:
+  GetCookiesCommand(RenderFrameHostImpl* frame_host,
+                    std::unique_ptr<GetCookiesCallback> callback)
+      : GetCookiesCommandBase(std::move(callback)) {
+    net::CookieStore::GetCookieListCallback got_cookies_callback = base::Bind(
+        &GetCookiesCommand::GotCookiesForURL, base::Unretained(this));
+
+    std::queue<FrameTreeNode*> queue;
+    queue.push(frame_host->frame_tree_node());
+    while (!queue.empty()) {
+      FrameTreeNode* node = queue.front();
+      queue.pop();
+
+      // Only traverse nodes with the same local root.
+      if (node->current_frame_host()->IsCrossProcessSubframe())
+        continue;
+      ++request_count_;
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&GetCookiesForURLOnIO,
+                     base::Unretained(frame_host->GetSiteInstance()
+                                          ->GetBrowserContext()
+                                          ->GetResourceContext()),
+                     base::Unretained(frame_host->GetProcess()
+                                          ->GetStoragePartition()
+                                          ->GetURLRequestContext()),
+                     node->current_url(), got_cookies_callback));
+
+      for (size_t i = 0; i < node->child_count(); ++i)
+        queue.push(node->child_at(i));
+    }
+  }
+};
+
+class GetAllCookiesCommand
+    : public GetCookiesCommandBase<GetAllCookiesCallback> {
+ public:
+  GetAllCookiesCommand(RenderFrameHostImpl* frame_host,
+                       std::unique_ptr<GetAllCookiesCallback> callback)
+      : GetCookiesCommandBase(std::move(callback)) {
+    net::CookieStore::GetCookieListCallback got_cookies_callback = base::Bind(
+        &GetAllCookiesCommand::GotCookiesForURL, base::Unretained(this));
+
+    request_count_ = 1;
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&GetAllCookiesOnIO,
+                   base::Unretained(frame_host->GetSiteInstance()
+                                        ->GetBrowserContext()
+                                        ->GetResourceContext()),
+                   base::Unretained(frame_host->GetProcess()
+                                        ->GetStoragePartition()
+                                        ->GetURLRequestContext()),
+                   got_cookies_callback));
+  }
+};
+
 }  // namespace
 
 NetworkHandler::NetworkHandler()
@@ -290,12 +305,19 @@ Response NetworkHandler::ClearBrowserCookies() {
 }
 
 void NetworkHandler::GetCookies(
-    Maybe<bool> global,
     std::unique_ptr<GetCookiesCallback> callback) {
   if (!host_)
     callback->sendFailure(Response::InternalError());
   else
-    new GetCookiesCommand(host_, global.fromMaybe(false), std::move(callback));
+    new GetCookiesCommand(host_, std::move(callback));
+}
+
+void NetworkHandler::GetAllCookies(
+    std::unique_ptr<GetAllCookiesCallback> callback) {
+  if (!host_)
+    callback->sendFailure(Response::InternalError());
+  else
+    new GetAllCookiesCommand(host_, std::move(callback));
 }
 
 void NetworkHandler::SetCookie(

content/browser/devtools/protocol/network_handler.h

@@ -30,8 +30,8 @@ class NetworkHandler : public Network::Backend {
   Response ClearBrowserCache() override;
   Response ClearBrowserCookies() override;
 
-  void GetCookies(Maybe<bool> global,
-                  std::unique_ptr<GetCookiesCallback> callback) override;
+  void GetCookies(std::unique_ptr<GetCookiesCallback> callback) override;
+  void GetAllCookies(std::unique_ptr<GetAllCookiesCallback> callback) override;
   void DeleteCookie(const std::string& cookie_name,
                     const std::string& url,
                     std::unique_ptr<DeleteCookieCallback> callback) override;

content/browser/devtools/protocol_config.json

@@ -32,10 +32,10 @@
             },
             {
                 "domain": "Network",
-                "include": ["enable", "disable", "clearBrowserCache", "clearBrowserCookies", "getCookies", "deleteCookie", "setCookie", "canEmulateNetworkConditions"],
+                "include": ["enable", "disable", "clearBrowserCache", "clearBrowserCookies", "getCookies", "getAllCookies", "deleteCookie", "setCookie", "canEmulateNetworkConditions"],
                 "include_types": ["CookieSameSite", "Cookie"],
                 "include_events": [],
-                "async": ["getCookies", "deleteCookie", "setCookie"]
+                "async": ["getCookies", "getAllCookies", "deleteCookie", "setCookie"]
             },
             {
                 "domain": "Page",

third_party/WebKit/Source/core/inspector/browser_protocol.json

@@ -1227,9 +1227,14 @@
             },
             {
                 "name": "getCookies",
-                "parameters": [
-                    { "name": "global", "type": "boolean", "optional": true, "description": "If true, returns all cookies, otherwise only the cookies for the current URL." }
+                "returns": [
+                    { "name": "cookies", "type": "array", "items": { "$ref": "Cookie" }, "description": "Array of cookie objects." }
                 ],
+                "description": "Returns all browser cookies for the current URL. Depending on the backend support, will return detailed cookie information in the <code>cookies</code> field.",
+                "experimental": true
+            },
+            {
+                "name": "getAllCookies",
                 "returns": [
                     { "name": "cookies", "type": "array", "items": { "$ref": "Cookie" }, "description": "Array of cookie objects." }
                 ],

third_party/WebKit/Source/core/inspector/inspector_protocol_config.json

@@ -89,7 +89,7 @@
             },
             {
                 "domain": "Network",
-                "exclude": ["clearBrowserCache", "clearBrowserCookies", "getCookies", "deleteCookie", "setCookie", "canEmulateNetworkConditions"],
+                "exclude": ["clearBrowserCache", "clearBrowserCookies", "getCookies", "getAllCookies", "deleteCookie", "setCookie", "canEmulateNetworkConditions"],
                 "async": ["getResponseBody"]
             },
             {

third_party/WebKit/Source/devtools/front_end/sdk/CookieParser.js

@@ -384,10 +384,8 @@ SDK.Cookies.getCookiesAsync = function(callback) {
   }
 
   var barrier = new CallbackBarrier();
-  for (var target of SDK.targetManager.targets(SDK.Target.Capability.Network)) {
-    var global = false;
-    target.networkAgent().getCookies(global, barrier.createCallback(mycallback.bind(null, target)));
-  }
+  for (var target of SDK.targetManager.targets(SDK.Target.Capability.Network))
+    target.networkAgent().getCookies(barrier.createCallback(mycallback.bind(null, target)));
   barrier.callWhenDone(callback.bind(null, allCookies));
 };