Implement important sites dialog for desktop.

chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.cc

 // Copyright 2015 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/ui/webui/settings/settings_clear_browsing_data_handler.h"
 
 #include <stddef.h>
+#include <vector>
 
+#include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_counter_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_counter_utils.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
+#include "chrome/browser/browsing_data/browsing_data_remover_util.h"
+#include "chrome/browser/engagement/important_sites_util.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/channel_info.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "components/browsing_data/core/history_notice_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/web_ui.h"
 
 namespace {
 
 const int kMaxTimesHistoryNoticeShown = 1;
 
+const int kMaxImportantSites = 10;
+
 // TODO(msramek): Get the list of deletion preferences from the JS side.
 const char* kCounterPrefs[] = {
   browsing_data::prefs::kDeleteBrowsingHistory,
   browsing_data::prefs::kDeleteCache,
   browsing_data::prefs::kDeleteDownloadHistory,
   browsing_data::prefs::kDeleteFormData,
   browsing_data::prefs::kDeleteHostedAppsData,
   browsing_data::prefs::kDeleteMediaLicenses,
   browsing_data::prefs::kDeletePasswords,
 };
 
+const char* REGISTERABLE_DOMAINS_FIELD = "registerableDomain";
+const char* REASON_BITFIELD_FIELD = "reasonBitfield";
+const char* EXAMPLE_ORIGIN_FIELD = "exampleOrigin";
+const char* DIALOG_DISABLED_FIELD = "dialogDisabled";
+const char* IMPORTANT_SITES_FIELD = "importantSites";
+const char* IS_CHECKED_FIELD = "isChecked";
+const char* STORAGE_SIZE_FIELD = "storageSize";
+const char* HAS_NOTIFICATIONS_FIELD = "hasNotifications";
+
 } // namespace
 
 namespace settings {
 
 // TaskObserver ----------------------------------------------------------------
 
 class ClearBrowsingDataHandler::TaskObserver
     : public BrowsingDataRemover::Observer {
  public:
-  TaskObserver(BrowsingDataRemover* remover, const base::Closure& callback);
+  TaskObserver(BrowsingDataRemover* remover,
+               const base::Closure& callback,
+               int task_count);
   ~TaskObserver() override;
 
   void OnBrowsingDataRemoverDone() override;
 
  private:
   base::Closure callback_;
   ScopedObserver<BrowsingDataRemover, BrowsingDataRemover::Observer>
       remover_observer_;
+  int task_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskObserver);
 };
 
 ClearBrowsingDataHandler::TaskObserver::TaskObserver(
-    BrowsingDataRemover* remover, const base::Closure& callback)
-    : callback_(callback),
-      remover_observer_(this) {
+    BrowsingDataRemover* remover,
+    const base::Closure& callback,
+    int task_count)
+    : callback_(callback), remover_observer_(this), task_count_(task_count) {
   remover_observer_.Add(remover);
 }
 
 ClearBrowsingDataHandler::TaskObserver::~TaskObserver() {}
 
 void ClearBrowsingDataHandler::TaskObserver::OnBrowsingDataRemoverDone() {
+  DCHECK(task_count_);
+  if (--task_count_)
+    return;
   remover_observer_.RemoveAll();
   callback_.Run();
 }
 
 // ClearBrowsingDataHandler ----------------------------------------------------
 
 ClearBrowsingDataHandler::ClearBrowsingDataHandler(content::WebUI* webui)
     : profile_(Profile::FromWebUI(webui)),
       sync_service_(ProfileSyncServiceFactory::GetForProfile(profile_)),
       sync_service_observer_(this),
       show_history_footer_(false),
       show_history_deletion_dialog_(false),
       weak_ptr_factory_(this) {}
 
 ClearBrowsingDataHandler::~ClearBrowsingDataHandler() {
 }
 
 void ClearBrowsingDataHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "clearBrowsingData",
       base::Bind(&ClearBrowsingDataHandler::HandleClearBrowsingData,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
+      "fetchImportantSites",
+      base::Bind(&ClearBrowsingDataHandler::HandleFetchImportantSites,
+                 base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
       "initializeClearBrowsingData",
       base::Bind(&ClearBrowsingDataHandler::HandleInitialize,
                  base::Unretained(this)));
 }
 
 void ClearBrowsingDataHandler::OnJavascriptAllowed() {
   if (sync_service_)
     sync_service_observer_.Add(sync_service_);
 
   DCHECK(counters_.empty());
@@ skipping 83 matching lines @@
         [prefs](const std::string& pref) { return prefs->GetBoolean(pref); });
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "History.ClearBrowsingData.PasswordsDeletion.AdditionalDatatypesCount",
         checked_other_types);
   }
 
   int period_selected =
       prefs->GetInteger(browsing_data::prefs::kDeleteTimePeriod);
 
   std::string webui_callback_id;
-  CHECK_EQ(1U, args->GetSize());
+  CHECK_EQ(2U, args->GetSize());
   CHECK(args->GetString(0, &webui_callback_id));
 
+  std::vector<std::string> excluding_domains;
+  std::vector<int32_t> excluding_domain_reasons;
+  std::vector<std::string> ignoring_domains;
+  std::vector<int32_t> ignoring_domain_reasons;
+  const base::ListValue* important_sites = nullptr;
+  CHECK(args->GetList(1, &important_sites));
+  for (const auto& item : *important_sites) {
+    const base::DictionaryValue* site = nullptr;
+    CHECK(item->GetAsDictionary(&site));
+    bool is_checked = false;
+    CHECK(site->GetBoolean(IS_CHECKED_FIELD, &is_checked));
+    std::string domain;
+    int domain_reason = -1;
+    CHECK(site->GetString(REGISTERABLE_DOMAINS_FIELD, &domain));
+    CHECK(site->GetInteger(REASON_BITFIELD_FIELD, &domain_reason));
+    if (is_checked) {  // Selected important sites should be deleted.
+      ignoring_domains.push_back(domain);
+      ignoring_domain_reasons.push_back(domain_reason);
+    } else {  // Unselected sites should be kept.
+      excluding_domains.push_back(domain);
+      excluding_domain_reasons.push_back(domain_reason);
+    }
+  }
+
+  if (!excluding_domains.empty() || !ignoring_domains.empty()) {
+    ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
+        profile_->GetOriginalProfile(), excluding_domains,
+        excluding_domain_reasons, ignoring_domains, ignoring_domain_reasons);
+  }
+
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(profile_);
   task_observer_ = base::MakeUnique<TaskObserver>(
       remover,
       base::Bind(&ClearBrowsingDataHandler::OnClearingTaskFinished,
-                 base::Unretained(this), webui_callback_id));
+                 base::Unretained(this), webui_callback_id),
+      /*task_count=*/2);
   browsing_data::TimePeriod time_period =
       static_cast<browsing_data::TimePeriod>(period_selected);
-  browsing_data::RecordDeletionForPeriod(time_period);
-  remover->RemoveAndReply(
-      browsing_data::CalculateBeginDeleteTime(time_period),
-      browsing_data::CalculateEndDeleteTime(time_period),
-      remove_mask, origin_mask, task_observer_.get());
+
+  BrowsingDataRemoverUtil::Remove(remove_mask, origin_mask, time_period,
+                                  excluding_domains, remover,
+                                  task_observer_.get());
 }
 
 void ClearBrowsingDataHandler::OnClearingTaskFinished(
     const std::string& webui_callback_id) {
   PrefService* prefs = profile_->GetPrefs();
   int notice_shown_times = prefs->GetInteger(
       browsing_data::prefs::kClearBrowsingDataHistoryNoticeShownTimes);
 
   // When the deletion is complete, we might show an additional dialog with
   // a notice about other forms of browsing history. This is the case if
@@ skipping 13 matching lines @@
   }
 
   UMA_HISTOGRAM_BOOLEAN(
       "History.ClearBrowsingData.ShownHistoryNoticeAfterClearing", show_notice);
 
   ResolveJavascriptCallback(base::StringValue(webui_callback_id),
                             base::Value(show_notice));
   task_observer_.reset();
 }
 
+void ClearBrowsingDataHandler::HandleFetchImportantSites(
+    const base::ListValue* args) {
+  AllowJavascript();
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+
+  Profile* profile = profile_->GetOriginalProfile();
+  bool dialog_disabled =
+      ImportantSitesUtil::IsDialogDisabled(profile) ||
+      !base::FeatureList::IsEnabled(features::kImportantSitesInCBD);
+  auto important_sites_list = base::MakeUnique<base::ListValue>();
+
+  if (!dialog_disabled) {
+    std::vector<ImportantSitesUtil::ImportantDomainInfo> important_sites =
+        ImportantSitesUtil::GetImportantRegisterableDomains(profile,
+                                                            kMaxImportantSites);
+    for (const auto& info : important_sites) {
+      auto entry = base::MakeUnique<base::DictionaryValue>();
+      entry->SetString(REGISTERABLE_DOMAINS_FIELD, info.registerable_domain);
+      entry->SetInteger(REASON_BITFIELD_FIELD, info.reason_bitfield);
+      entry->SetString(EXAMPLE_ORIGIN_FIELD, info.example_origin.spec());
+      // Initially all sites are selected for deletion.
+      entry->SetBoolean(IS_CHECKED_FIELD, true);
+      // TODO(dullweber): Get size and notification status.
+      entry->SetInteger(STORAGE_SIZE_FIELD, 0);
+      entry->SetBoolean(HAS_NOTIFICATIONS_FIELD, true);
+      important_sites_list->Append(std::move(entry));
+    }
+  }
+
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  result->SetBoolean(DIALOG_DISABLED_FIELD, dialog_disabled);
+  result->Set(IMPORTANT_SITES_FIELD, std::move(important_sites_list));
+
+  ResolveJavascriptCallback(*callback_id, *result);
+}
+
 void ClearBrowsingDataHandler::HandleInitialize(const base::ListValue* args) {
   AllowJavascript();
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
   // Needed because WebUI doesn't handle renderer crashes. See crbug.com/610450.
   task_observer_.reset();
 
   UpdateSyncState();
   RefreshHistoryNotice();
@@ skipping 66 matching lines @@
 
 void ClearBrowsingDataHandler::UpdateCounterText(
     std::unique_ptr<browsing_data::BrowsingDataCounter::Result> result) {
   CallJavascriptFunction(
       "cr.webUIListenerCallback", base::StringValue("update-counter-text"),
       base::StringValue(result->source()->GetPrefName()),
       base::StringValue(GetChromeCounterTextFromResult(result.get())));
 }
 
 }  // namespace settings