Count number of origins with data affected by clearing "cookies and site data".

chrome/browser/browsing_data/site_data_counting_helper_browsertest.cc

+// Copyright 2017 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 <algorithm>
+#include <memory>
+#include <set>
+#include <string>
+
+#include "base/run_loop.h"
+#include "chrome/browser/browsing_data/site_data_counting_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
+#include "net/cookies/cookie_store.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+using content::BrowserThread;
+
+class SiteDataCountingHelperBrowserTest : public InProcessBrowserTest {
+ public:
+  const int64_t kTimeoutMs = 10;
+
+  void SetUpOnMainThread() override {
+    tasks_ = 0;
+    cookie_callback_ =
+        base::Bind(&SiteDataCountingHelperBrowserTest::CookieCallback,
+                   base::Unretained(this));
+  }
+
+  void TearDownOnMainThread() override {}

[msramek, 2017/01/10 10:23:02]

Do we need this?

[dullweber, 2017/01/10 13:18:34]

Done.

+
+  void CookieCallback(int count) {
+    // Negative values represent an unexpected error.
+    DCHECK(count >= 0);
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    last_count_ = count;
+
+    if (run_loop_)
+      run_loop_->Quit();
+  }
+
+  void DoneOnIOThread(bool success) {
+    DCHECK(success);
+    if (--tasks_ > 0)
+      return;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&SiteDataCountingHelperBrowserTest::DoneCallback,
+                   base::Unretained(this)));
+  }
+
+  void DoneCallback() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    if (run_loop_)
+      run_loop_->Quit();
+  }
+
+  void WaitForTasksOnIOThread() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    run_loop_.reset(new base::RunLoop());
+    run_loop_->Run();
+  }
+
+  void CreateCookies(base::Time creation_time, std::vector<GURL> urls) {
+    content::StoragePartition* partition =
+        content::BrowserContext::GetDefaultStoragePartition(
+            browser()->profile());
+    net::URLRequestContextGetter* rq_context =
+        partition->GetURLRequestContext();
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&SiteDataCountingHelperBrowserTest::CreateCookiesOnIOThread,
+                   base::Unretained(this), make_scoped_refptr(rq_context),
+                   creation_time, urls));
+  }
+
+  void CreateCookiesOnIOThread(
+      const scoped_refptr<net::URLRequestContextGetter>& rq_context,
+      base::Time creation_time,
+      std::vector<GURL> urls) {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+    net::CookieStore* cookie_store =
+        rq_context->GetURLRequestContext()->cookie_store();
+
+    tasks_ = urls.size();
+    int i = 0;
+    for (const GURL& url : urls) {
+      // Cookies need a unique creation time.
+      base::Time time = creation_time + base::TimeDelta::FromMilliseconds(i++);
+      cookie_store->SetCookieWithDetailsAsync(
+          url, "name", "A=1", url.host(), url.path(), time, base::Time(), time,
+          true, false, net::CookieSameSite::DEFAULT_MODE, false,
+          net::COOKIE_PRIORITY_DEFAULT,
+          base::Bind(&SiteDataCountingHelperBrowserTest::DoneOnIOThread,
+                     base::Unretained(this)));
+    }
+  }
+
+  void CountEntries(base::Time begin_time) {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    last_count_ = -1;
+    auto helper = new SiteDataCountingHelper(browser()->profile(), begin_time,
+                                             cookie_callback_);
+    helper->CountAndDestroySelfWhenFinished();
+  }
+
+  int64_t GetResult() {
+    DCHECK_GE(last_count_, 0);
+    return last_count_;
+  }
+
+ private:
+  base::Callback<void(int)> cookie_callback_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+
+  volatile int tasks_;

[msramek, 2017/01/10 10:23:02]

I don't think volatile is necessary here.

[dullweber, 2017/01/10 13:18:34]

Done.

+  int64_t last_count_;
+};
+

[msramek, 2017/01/10 10:23:02]

Could you please add a test for one other data storage backend, and then also
one for the fact that the same origin from two different data storage backends
(e.g. cookies and local storage) is not counted twice?

[dullweber, 2017/01/10 13:18:34]

added a test for localstorage and the combination of localstorage and cookies

+IN_PROC_BROWSER_TEST_F(SiteDataCountingHelperBrowserTest, CheckEmptyResult) {
+  CountEntries(base::Time());
+  WaitForTasksOnIOThread();
+
+  DCHECK_EQ(0, GetResult());
+}
+
+IN_PROC_BROWSER_TEST_F(SiteDataCountingHelperBrowserTest, CountCookies) {
+  base::Time now = base::Time::Now();
+  base::Time last_hour = now - base::TimeDelta::FromHours(1);
+  base::Time yesterday = now - base::TimeDelta::FromDays(1);
+
+  CreateCookies(last_hour, {GURL("https://example.com")});
+  WaitForTasksOnIOThread();
+
+  CreateCookies(yesterday,
+                {GURL("https://google.com"), GURL("https://bing.com")});
+  WaitForTasksOnIOThread();
+
+  CountEntries(base::Time());
+  WaitForTasksOnIOThread();
+  DCHECK_EQ(3, GetResult());
+
+  CountEntries(yesterday);
+  WaitForTasksOnIOThread();
+  DCHECK_EQ(3, GetResult());
+
+  CountEntries(last_hour);
+  WaitForTasksOnIOThread();
+  DCHECK_EQ(1, GetResult());
+
+  CountEntries(now);
+  WaitForTasksOnIOThread();
+  DCHECK_EQ(0, GetResult());
+}