devtools: Make it possible to retrieve all cookies

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 67 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GetCookiesForURLOnIO,
                  base::Unretained(resource_context),
                  base::Unretained(context_getter),
                  url,
                  callback));
 }
 
+void GetCookiesOnIO(ResourceContext* resource_context,
+                    net::URLRequestContextGetter* context_getter,
+                    const CookieListCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::URLRequestContext* request_context =
+      context_getter->GetURLRequestContext();
+  request_context->cookie_store()->GetAllCookiesAsync(
+      base::Bind(&GotCookiesForURLOnIO, callback));
+}
+
+void GetCookiesOnUI(ResourceContext* resource_context,
+                    net::URLRequestContextGetter* context_getter,
+                    const CookieListCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&GetCookiesOnIO, base::Unretained(resource_context),
+                 base::Unretained(context_getter), callback));
+}
+
 void DeletedCookieOnIO(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       callback);
 }
 
 void DeleteCookieOnIO(
     ResourceContext* resource_context,
@@ skipping 87 matching lines @@
       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) {
+  GetCookiesCommand(RenderFrameHostImpl* frame_host,
+                    bool global,
+                    const CookieListCallback& callback)
+      : callback_(callback), request_count_(0) {
     CookieListCallback got_cookies_callback = base::Bind(
         &GetCookiesCommand::GotCookiesForURL, base::Unretained(this));
 
+    if (global) {
+      request_count_ = 1;
+      GetCookiesOnUI(frame_host->GetSiteInstance()
+                         ->GetBrowserContext()
+                         ->GetResourceContext(),
+                     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_;
@@ skipping 73 matching lines @@
     GetContentClient()->browser()->ClearCache(host_);
   return Response::OK();
 }
 
 Response NetworkHandler::ClearBrowserCookies() {
   if (host_)
     GetContentClient()->browser()->ClearCookies(host_);
   return Response::OK();
 }
 
-Response NetworkHandler::GetCookies(DevToolsCommandId command_id) {
+Response NetworkHandler::GetCookies(DevToolsCommandId command_id,
+                                    const bool* global) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
-  new GetCookiesCommand(
-      host_,
-      base::Bind(&NetworkHandler::SendGetCookiesResponse,
-                 weak_factory_.GetWeakPtr(),
-                 command_id));
+  new GetCookiesCommand(host_, global ? *global : false,
+                        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,
@@ skipping 100 matching lines @@
     double latency,
     double download_throughput,
     double upload_throughput,
     const std::string* connection_type) {
   return Response::FallThrough();
 }
 
 }  // namespace network
 }  // namespace devtools
 }  // namespace content