DevTools: Fix Network.clearBrowserCookies

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/barrier_closure.h"
 #include "base/command_line.h"
@@ skipping 174 matching lines @@
 
 void DeletedCookieOnIO(std::unique_ptr<DeleteCookieCallback> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DeleteCookieCallback::sendSuccess,
                  base::Passed(std::move(callback))));
 }
 
+void ClearedCookiesOnIO(int num_deleted) {

[phulce, 2017/03/31 16:40:42]

It'd be nice to communicate this over the protocol, but it looks like that
method is marked as stable and doesn't accept a callback. Is that something we
can change or we'll just have to live with?

[dgozman, 2017/03/31 22:57:55]

You can mark it "async" in protocol_config.json, in which case there would be a
callback.

[phulce, 2017/03/31 23:54:32]

done

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+}
+
+void ClearCookiesOnIO(ResourceContext* resource_context,
+                      net::URLRequestContextGetter* context_getter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::URLRequestContext* request_context =
+      context_getter->GetURLRequestContext();
+  request_context->cookie_store()->DeleteAllAsync(
+      base::Bind(&ClearedCookiesOnIO));
+}
+
 void DeleteCookieOnIO(
     ResourceContext* resource_context,
     net::URLRequestContextGetter* context_getter,
     const GURL& url,
     const std::string& cookie_name,
     std::unique_ptr<DeleteCookieCallback> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::URLRequestContext* request_context =
       GetRequestContextOnIO(resource_context, context_getter, url);
   request_context->cookie_store()->DeleteCookieAsync(
@@ skipping 227 matching lines @@
   return Response::FallThrough();
 }
 
 Response NetworkHandler::ClearBrowserCache() {
   if (host_)
     GetContentClient()->browser()->ClearCache(host_);
   return Response::OK();
 }
 
 Response NetworkHandler::ClearBrowserCookies() {
-  if (host_)
-    GetContentClient()->browser()->ClearCookies(host_);
+  if (!host_) {
+    return Response::InternalError();
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearCookiesOnIO,
+                 base::Unretained(host_->GetSiteInstance()
+                                      ->GetBrowserContext()
+                                      ->GetResourceContext()),
+                 base::Unretained(host_->GetProcess()
+                                      ->GetStoragePartition()
+                                      ->GetURLRequestContext())));
   return Response::OK();
 }
 
 void NetworkHandler::GetCookies(Maybe<Array<String>> protocol_urls,
                                 std::unique_ptr<GetCookiesCallback> callback) {
   if (!host_) {
     callback->sendFailure(Response::InternalError());
     return;
   }
 
@@ skipping 266 matching lines @@
           static_cast<double>(base::Time::kMicrosecondsPerSecond),
       Page::ResourceTypeEnum::Document, error_string, cancelled);
 }
 
 std::string NetworkHandler::UserAgentOverride() const {
   return enabled_ ? user_agent_ : std::string();
 }
 
 }  // namespace protocol
 }  // namespace content