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/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_important_sites_util.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.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/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/browsing_data_filter_builder.h"
 #include "content/public/browser/web_ui.h"
+#include "ui/base/text/bytes_formatting.h"
+
+using ImportantReason = ImportantSitesUtil::ImportantReason;
 
 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 kRegisterableDomainField[] = "registerableDomain";
+const char kReasonBitField[] = "reasonBitfield";
+const char kExampleOriginField[] = "exampleOrigin";
+const char kImportantSitesField[] = "importantSites";
+const char kIsCheckedField[] = "isChecked";
+const char kStorageSizeField[] = "storageSize";
+const char kHasNotificationsField[] = "hasNotifications";
+
 } // namespace
 
 namespace settings {
 
-// TaskObserver ----------------------------------------------------------------
-
-class ClearBrowsingDataHandler::TaskObserver
-    : public content::BrowsingDataRemover::Observer {
- public:
-  TaskObserver(content::BrowsingDataRemover* remover,
-               const base::Closure& callback);
-  ~TaskObserver() override;
-
-  void OnBrowsingDataRemoverDone() override;
-
- private:
-  base::Closure callback_;
-  ScopedObserver<content::BrowsingDataRemover,
-                 content::BrowsingDataRemover::Observer>
-      remover_observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskObserver);
-};
-
-ClearBrowsingDataHandler::TaskObserver::TaskObserver(
-    content::BrowsingDataRemover* remover,
-    const base::Closure& callback)
-    : callback_(callback), remover_observer_(this) {
-  remover_observer_.Add(remover);
-}
-
-ClearBrowsingDataHandler::TaskObserver::~TaskObserver() {}
-
-void ClearBrowsingDataHandler::TaskObserver::OnBrowsingDataRemoverDone() {
-  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());
   for (const std::string& pref : kCounterPrefs) {
     AddCounter(
         BrowsingDataCounterFactory::GetForProfileAndPref(profile_, pref));
   }
 }
 
 void ClearBrowsingDataHandler::OnJavascriptDisallowed() {
   sync_service_observer_.RemoveAll();
-  task_observer_.reset();
+  weak_ptr_factory_.InvalidateWeakPtrs();
   counters_.clear();
 }
 
 void ClearBrowsingDataHandler::HandleClearBrowsingData(
     const base::ListValue* args) {
-  DCHECK(!task_observer_);
-
   PrefService* prefs = profile_->GetPrefs();
 
   int site_data_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_DATA;
   // Don't try to clear LSO data if it's not supported.
   if (!prefs->GetBoolean(prefs::kClearPluginLSODataEnabled))
     site_data_mask &= ~ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA;
 
   int remove_mask = 0;
   if (prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory)) {
     if (prefs->GetBoolean(browsing_data::prefs::kDeleteBrowsingHistory))
@@ skipping 57 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));
 
+  const base::ListValue* important_sites = nullptr;
+  CHECK(args->GetList(1, &important_sites));
+  std::unique_ptr<content::BrowsingDataFilterBuilder> filter_builder =
+      ProcessImportantSites(important_sites);
+
   content::BrowsingDataRemover* remover =
       content::BrowserContext::GetBrowsingDataRemover(profile_);
-  task_observer_ = base::MakeUnique<TaskObserver>(
-      remover,
-      base::Bind(&ClearBrowsingDataHandler::OnClearingTaskFinished,
-                 base::Unretained(this), webui_callback_id));
+
+  base::OnceClosure callback =
+      base::BindOnce(&ClearBrowsingDataHandler::OnClearingTaskFinished,
+                     weak_ptr_factory_.GetWeakPtr(), webui_callback_id);
   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());
+
+  browsing_data_important_sites_util::Remove(
+      remove_mask, origin_mask, time_period, std::move(filter_builder), remover,
+      std::move(callback));
+}
+
+std::unique_ptr<content::BrowsingDataFilterBuilder>
+ClearBrowsingDataHandler::ProcessImportantSites(
+    const base::ListValue* important_sites) {
+  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;
+  for (const auto& item : *important_sites) {
+    const base::DictionaryValue* site = nullptr;
+    CHECK(item.GetAsDictionary(&site));
+    bool is_checked = false;
+    CHECK(site->GetBoolean(kIsCheckedField, &is_checked));
+    std::string domain;
+    CHECK(site->GetString(kRegisterableDomainField, &domain));
+    int domain_reason = -1;
+    CHECK(site->GetInteger(kReasonBitField, &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);
+  }
+
+  std::unique_ptr<content::BrowsingDataFilterBuilder> filter_builder(
+      content::BrowsingDataFilterBuilder::Create(
+          content::BrowsingDataFilterBuilder::BLACKLIST));
+  for (const std::string& domain : excluding_domains) {
+    filter_builder->AddRegisterableDomain(domain);
+  }
+  return filter_builder;
 }
 
 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 10 matching lines @@
     prefs->SetInteger(
         browsing_data::prefs::kClearBrowsingDataHistoryNoticeShownTimes,
         notice_shown_times + 1);
   }
 
   UMA_HISTOGRAM_BOOLEAN(
       "History.ClearBrowsingData.ShownHistoryNoticeAfterClearing", show_notice);
 
   ResolveJavascriptCallback(base::Value(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 important_sites_dialog_disabled =
+      ImportantSitesUtil::IsDialogDisabled(profile);

[Dan Beam, 2017/05/16 19:46:09]

can we just

  DCHECK(!ImportantSitesUtil::IsDialogDisabled(profile));

or something now?

[dullweber, 2017/05/17 09:57:37]

ImportantSitesUtil::IsDialogDisabled is not checking for the flag but for other
conditions like "did the user ignore the important sites dialog recently".

[Dan Beam, 2017/05/17 20:57:28]

then maybe DCHECK() that the feature is enabled?  (which is what I thought this
was checking)

[dullweber, 2017/05/18 10:41:54]

DCHECK added

+  auto important_sites_list = base::MakeUnique<base::ListValue>();
+
+  if (!important_sites_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(kRegisterableDomainField, info.registerable_domain);
+      // The |reason_bitfield| is only passed to Javascript to be logged
+      // from |HandleClearBrowsingData|.
+      entry->SetInteger(kReasonBitField, info.reason_bitfield);
+      entry->SetString(kExampleOriginField, info.example_origin.spec());
+      // Initially all sites are selected for deletion.
+      entry->SetBoolean(kIsCheckedField, true);
+      // TODO(dullweber): Get size.
+      entry->SetString(kStorageSizeField, ui::FormatBytes(0));
+      bool has_notifications =
+          (info.reason_bitfield & (1 << ImportantReason::NOTIFICATIONS)) != 0;
+      entry->SetBoolean(kHasNotificationsField, has_notifications);
+      important_sites_list->Append(std::move(entry));
+    }
+  }
+
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  result->Set(kImportantSitesField, std::move(important_sites_list));

[Dan Beam, 2017/05/16 19:46:09]

why are we creating a dictionary with one field rather than just resolving with
important_sites_list directly?

[dullweber, 2017/05/17 09:57:37]

Done.

+
+  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();
+  weak_ptr_factory_.InvalidateWeakPtrs();
 
   UpdateSyncState();
   RefreshHistoryNotice();
 
   // Restart the counters each time the dialog is reopened.
   for (const auto& counter : counters_)
     counter->Restart();
 
   ResolveJavascriptCallback(*callback_id, base::Value() /* Promise<void> */);
 }
@@ skipping 57 matching lines @@
 
 void ClearBrowsingDataHandler::UpdateCounterText(
     std::unique_ptr<browsing_data::BrowsingDataCounter::Result> result) {
   CallJavascriptFunction(
       "cr.webUIListenerCallback", base::Value("update-counter-text"),
       base::Value(result->source()->GetPrefName()),
       base::Value(GetChromeCounterTextFromResult(result.get())));
 }
 
 }  // namespace settings