Count site data size for important sites

chrome/browser/engagement/important_sites_util_unittest.cc

 // Copyright 2016 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 "chrome/browser/engagement/important_sites_util.h"
 
 #include <memory>
 #include <utility>
 
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sample_vector.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/test/test_history_database.h"
 #include "components/keyed_service/core/keyed_service.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/test/mock_storage_client.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 using BookmarkModel = bookmarks::BookmarkModel;
 using ImportantDomainInfo = ImportantSitesUtil::ImportantDomainInfo;
+using content::BrowserThread;
+using content::DOMStorageContext;
+using storage::QuotaManager;
 
 const size_t kNumImportantSites = 5;
 base::FilePath g_temp_history_dir;
 
 std::unique_ptr<KeyedService> BuildTestHistoryService(
     content::BrowserContext* context) {
   std::unique_ptr<history::HistoryService> service(
       new history::HistoryService());
   service->Init(history::TestHistoryDatabaseParamsForPath(g_temp_history_dir));
   return std::move(service);
@@ skipping 20 matching lines @@
  public:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     SiteEngagementScore::SetParamValuesForTesting();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     g_temp_history_dir = temp_dir_.GetPath();
     HistoryServiceFactory::GetInstance()->SetTestingFactory(
         profile(), &BuildTestHistoryService);
   }
 
+  void TearDown() override {
+    base::RunLoop().RunUntilIdle();
+    quota_manager_ = nullptr;
+    ChromeRenderViewHostTestHarness::TearDown();
+  }
+
   void AddContentSetting(ContentSettingsType type,
                          ContentSetting setting,
                          const GURL& origin) {
     HostContentSettingsMapFactory::GetForProfile(profile())
         ->SetContentSettingCustomScope(
             ContentSettingsPattern::FromURLNoWildcard(origin),
             ContentSettingsPattern::Wildcard(), type,
             content_settings::ResourceIdentifier(), setting);
     EXPECT_EQ(setting,
               HostContentSettingsMapFactory::GetForProfile(profile())
@@ skipping 35 matching lines @@
     std::vector<GURL> actual_origins;
     for (size_t i = 0; i < important_sites.size(); i++) {
       actual_domains.push_back(important_sites[i].registerable_domain);
       actual_origins.push_back(important_sites[i].example_origin);
     }
     EXPECT_THAT(actual_domains, testing::UnorderedElementsAreArray(domains));
     EXPECT_THAT(actual_origins,
                 testing::UnorderedElementsAreArray(expected_sorted_origins));
   }
 
+  QuotaManager* CreateQuotaManager() {
+    quota_manager_ = new QuotaManager(
+        false, temp_dir_.GetPath(),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO).get(),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::DB).get(), nullptr,
+        storage::GetQuotaSettingsFunc());
+    return quota_manager_.get();
+  }
+
+  void RegisterClient(const std::vector<content::MockOriginData>& data) {
+    auto* client = new content::MockStorageClient(
+        quota_manager_->proxy(), data.data(), storage::QuotaClient::kFileSystem,
+        data.size());
+    quota_manager_->proxy()->RegisterClient(client);
+    client->TouchAllOriginsAndNotify();
+  }
+
+  void CreateLocalStorage(
+      base::Time creation_time,
+      int length,
+      const base::FilePath::StringPieceType& storage_origin) {
+    // Note: This test depends on details of how the dom_storage library
+    // stores data in the host file system.
+    base::FilePath storage_path =
+        profile()->GetPath().AppendASCII("Local Storage");
+    base::CreateDirectory(storage_path);
+
+    std::string data(' ', length);
+    // Write file to localstorage.
+    base::FilePath file_path = storage_path.Append(storage_origin);
+    base::WriteFile(file_path, data.c_str(), length);
+    base::TouchFile(file_path, creation_time, creation_time);
+  }
+
+  void FetchCompleted(std::vector<ImportantDomainInfo> domain_info) {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    domain_info_ = domain_info;
+    if (run_loop_)
+      run_loop_->Quit();
+  }
+
+  void WaitForTasksOnIOThread() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    run_loop_.reset(new base::RunLoop());
+    run_loop_->Run();

[dmurph, 2017/03/27 22:22:45]

What would happen if we just created a runloop and did RunUntilIdle, instead of
calling quit above? This would be cleaner, as we don't need the local variable
or the special method.

[dullweber, 2017/03/28 14:06:45]

That works :) I thought RunUntilIdle() only waits for tasks on the UI thread and
that thread is idle for most of the time until the callback is executed but
TestBrowserThreadBundle only has a single thread for all tasks.

+  }
+
+  const std::vector<ImportantDomainInfo>& domain_info() { return domain_info_; }
+
  private:
   base::ScopedTempDir temp_dir_;
   BookmarkModel* model_ = nullptr;
+
+  std::unique_ptr<base::RunLoop> run_loop_;
+  scoped_refptr<QuotaManager> quota_manager_;
+  std::vector<ImportantDomainInfo> domain_info_;
 };
 
 TEST_F(ImportantSitesUtilTest, TestNoImportantSites) {
   EXPECT_TRUE(ImportantSitesUtil::GetImportantRegisterableDomains(
                   profile(), kNumImportantSites)
                   .empty());
 }
 
 TEST_F(ImportantSitesUtilTest, SourceOrdering) {
   SiteEngagementService* service = SiteEngagementService::Get(profile());
@@ skipping 322 matching lines @@
 
   // Items should still be present.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
                            important_sites);
 
   // Dialog should be blacklisted.
   EXPECT_TRUE(ImportantSitesUtil::IsDialogDisabled(profile()));
 }
+
+TEST_F(ImportantSitesUtilTest, PopulateUsage) {
+  std::vector<ImportantDomainInfo> important_sites;
+  ImportantDomainInfo i1;
+  i1.registerable_domain = "example.com";
+  ImportantDomainInfo i2;
+  i2.registerable_domain = "somethingelse.com";
+  important_sites.push_back(i1);
+  important_sites.push_back(i2);
+
+  const std::vector<content::MockOriginData> origins = {
+      {"http://example.com/", storage::kStorageTypeTemporary, 1},
+      {"https://example.com/", storage::kStorageTypeTemporary, 2},
+      {"https://maps.example.com/", storage::kStorageTypeTemporary, 4},
+      {"http://google.com/", storage::kStorageTypePersistent, 8},
+  };
+
+  auto* quota_manager = CreateQuotaManager();
+  RegisterClient(origins);
+
+  base::Time now = base::Time::Now();
+  CreateLocalStorage(now, 16,
+                     FILE_PATH_LITERAL("https_example.com_443.localstorage"));
+  CreateLocalStorage(now, 32,
+                     FILE_PATH_LITERAL("https_bing.com_443.localstorage"));
+  auto* dom_storage_context =
+      content::BrowserContext::GetDefaultStoragePartition(profile())
+          ->GetDOMStorageContext();
+
+  ImportantSitesUtil::PopulateUsage(
+      quota_manager, dom_storage_context, important_sites,
+      base::Bind(&ImportantSitesUtilTest::FetchCompleted,
+                 base::Unretained(this)));
+  WaitForTasksOnIOThread();
+
+  EXPECT_EQ(important_sites.size(), domain_info().size());
+  EXPECT_EQ("example.com", domain_info()[0].registerable_domain);
+  EXPECT_EQ(1 + 2 + 4 + 16, domain_info()[0].usage);
+  EXPECT_EQ("somethingelse.com", domain_info()[1].registerable_domain);
+  EXPECT_EQ(0, domain_info()[1].usage);
+}