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 30 matching lines @@
 
 namespace content {
 namespace protocol {
 namespace {
 
 using ProtocolCookieArray = Array<Network::Cookie>;
 using GetCookiesCallback = Network::Backend::GetCookiesCallback;
 using GetAllCookiesCallback = Network::Backend::GetAllCookiesCallback;
 using SetCookieCallback = Network::Backend::SetCookieCallback;
 using DeleteCookieCallback = Network::Backend::DeleteCookieCallback;
+using ClearBrowserCookiesCallback =
+    Network::Backend::ClearBrowserCookiesCallback;
 
 net::URLRequestContext* GetRequestContextOnIO(
     ResourceContext* resource_context,
     net::URLRequestContextGetter* context_getter,
     const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::URLRequestContext* context =
       GetContentClient()->browser()->OverrideRequestContextForURL(
           url, resource_context);
   if (!context)
@@ skipping 115 matching lines @@
 
     std::unique_ptr<GetCookiesCallback> callback_;
     std::unique_ptr<GetAllCookiesCallback> all_callback_;
     int callback_count_ = 0;
     std::unordered_map<std::string, net::CanonicalCookie> cookies_;
 
   private:
     friend class base::RefCountedThreadSafe<CookieRetriever>;
 };
 
+void ClearedCookiesOnIO(std::unique_ptr<ClearBrowserCookiesCallback> callback,
+                        int num_deleted) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&ClearBrowserCookiesCallback::sendSuccess,
+                                     base::Passed(std::move(callback))));
+}
+
+void ClearCookiesOnIO(ResourceContext* resource_context,
+                      net::URLRequestContextGetter* context_getter,
+                      std::unique_ptr<ClearBrowserCookiesCallback> callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::URLRequestContext* request_context =
+      context_getter->GetURLRequestContext();
+  request_context->cookie_store()->DeleteAllAsync(
+      base::Bind(&ClearedCookiesOnIO, base::Passed(std::move(callback))));
+}
+
 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 DeleteCookieOnIO(
@@ skipping 235 matching lines @@
   user_agent_ = std::string();
   return Response::FallThrough();
 }
 
 Response NetworkHandler::ClearBrowserCache() {
   if (host_)
     GetContentClient()->browser()->ClearCache(host_);
   return Response::OK();
 }
 
-Response NetworkHandler::ClearBrowserCookies() {
-  if (host_)
-    GetContentClient()->browser()->ClearCookies(host_);
-  return Response::OK();
+void NetworkHandler::ClearBrowserCookies(
+    std::unique_ptr<ClearBrowserCookiesCallback> callback) {
+  if (!host_) {
+    callback->sendFailure(Response::InternalError());
+    return;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearCookiesOnIO,
+                 base::Unretained(host_->GetSiteInstance()
+                                      ->GetBrowserContext()
+                                      ->GetResourceContext()),
+                 base::Unretained(host_->GetProcess()
+                                      ->GetStoragePartition()
+                                      ->GetURLRequestContext()),
+                 base::Passed(std::move(callback))));
 }
 
 void NetworkHandler::GetCookies(Maybe<Array<String>> protocol_urls,
                                 std::unique_ptr<GetCookiesCallback> callback) {
   if (!host_) {
     callback->sendFailure(Response::InternalError());
     return;
   }
 
   std::vector<GURL> urls = ComputeCookieURLs(host_, protocol_urls);
@@ skipping 265 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