Make GetDismissedSuggestionsForDebugging asynchronous

chrome/browser/ui/webui/snippets_internals_message_handler.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/ui/webui/snippets_internals_message_handler.h"
 
 #include <memory>
 #include <set>
 #include <vector>
 
@@ skipping 61 matching lines @@
   }
   return std::string();
 }
 
 } // namespace
 
 SnippetsInternalsMessageHandler::SnippetsInternalsMessageHandler()
     : content_suggestions_service_observer_(this),
       dom_loaded_(false),
       ntp_snippets_service_(nullptr),
-      content_suggestions_service_(nullptr) {}
+      content_suggestions_service_(nullptr),
+      weak_ptr_factory_(this) {}
 
 SnippetsInternalsMessageHandler::~SnippetsInternalsMessageHandler() {}
 
 void SnippetsInternalsMessageHandler::RegisterMessages() {
   // additional initialization (web_ui() does not work from the constructor)
   Profile* profile = Profile::FromWebUI(web_ui());
 
   content_suggestions_service_ =
       ContentSuggestionsServiceFactory::GetInstance()->GetForProfile(profile);
   content_suggestions_service_observer_.Add(content_suggestions_service_);
@@ skipping 12 matching lines @@
   web_ui()->RegisterMessageCallback(
       "clearCachedSuggestions",
       base::Bind(&SnippetsInternalsMessageHandler::HandleClearCachedSuggestions,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "clearDismissedSuggestions",
       base::Bind(
           &SnippetsInternalsMessageHandler::HandleClearDismissedSuggestions,
           base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "toggleDismissedSuggestions",
+      base::Bind(
+          &SnippetsInternalsMessageHandler::HandleToggleDismissedSuggestions,
+          base::Unretained(this)));
 }
 
 void SnippetsInternalsMessageHandler::OnNewSuggestions(Category category) {
   if (!dom_loaded_)
     return;
   SendContentSuggestions();
 }
 
 void SnippetsInternalsMessageHandler::OnCategoryStatusChanged(
     Category category,
@@ skipping 12 matching lines @@
 }
 
 void SnippetsInternalsMessageHandler::ContentSuggestionsServiceShutdown() {}
 
 void SnippetsInternalsMessageHandler::HandleRefreshContent(
     const base::ListValue* args) {
   DCHECK_EQ(0u, args->GetSize());
 
   dom_loaded_ = true;
 
+  for (std::pair<const Category, DismissedState>& category_state_pair :
+       dismissed_state_) {
+    if (category_state_pair.second == DismissedState::VISIBLE) {
+      category_state_pair.second = DismissedState::LOADING;
+      content_suggestions_service_->GetDismissedSuggestionsForDebugging(
+          category_state_pair.first,
+          base::Bind(
+              &SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded,
+              weak_ptr_factory_.GetWeakPtr(), category_state_pair.first));
+    }
+  }
+
   SendAllContent();
 }
 
 void SnippetsInternalsMessageHandler::HandleDownload(
     const base::ListValue* args) {
   DCHECK_EQ(1u, args->GetSize());
 
   SendString("hosts-status", std::string());
 
   std::string hosts_string;
@@ skipping 28 matching lines @@
 
   int category_id;
   if (!args->GetInteger(0, &category_id))
     return;
 
   Category category =
       content_suggestions_service_->category_factory()->FromIDValue(
           category_id);
   content_suggestions_service_->ClearDismissedSuggestionsForDebugging(category);
   SendContentSuggestions();
+  dismissed_state_[category] = DismissedState::LOADING;
+  content_suggestions_service_->GetDismissedSuggestionsForDebugging(
+      category,
+      base::Bind(&SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded,
+                 weak_ptr_factory_.GetWeakPtr(), category));
+}
+
+void SnippetsInternalsMessageHandler::HandleToggleDismissedSuggestions(
+    const base::ListValue* args) {
+  DCHECK_EQ(2u, args->GetSize());
+
+  int category_id;
+  if (!args->GetInteger(0, &category_id))
+    return;
+  bool dismissed_visible;
+  if (!args->GetBoolean(1, &dismissed_visible))
+    return;
+
+  Category category =
+      content_suggestions_service_->category_factory()->FromIDValue(
+          category_id);
+  if (dismissed_visible) {
+    dismissed_state_[category] = DismissedState::LOADING;
+    content_suggestions_service_->GetDismissedSuggestionsForDebugging(
+        category,
+        base::Bind(
+            &SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded,
+            weak_ptr_factory_.GetWeakPtr(), category));
+  } else {
+    dismissed_state_[category] = DismissedState::HIDDEN;
+    dismissed_suggestions_[category].clear();
+  }
 }
 
 void SnippetsInternalsMessageHandler::SendAllContent() {
   SendHosts();
 
   SendBoolean("flag-snippets", base::FeatureList::IsEnabled(
                                    ntp_snippets::kContentSuggestionsFeature));
   SendBoolean("flag-recent-offline-tab-suggestions",
               base::FeatureList::IsEnabled(
                   ntp_snippets::kRecentOfflineTabSuggestionsFeature));
@@ skipping 59 matching lines @@
 
   int index = 0;
   for (Category category : content_suggestions_service_->GetCategories()) {
     CategoryStatus status =
         content_suggestions_service_->GetCategoryStatus(category);
     base::Optional<CategoryInfo> info =
         content_suggestions_service_->GetCategoryInfo(category);
     DCHECK(info);
     const std::vector<ContentSuggestion>& suggestions =
         content_suggestions_service_->GetSuggestionsForCategory(category);
-    std::vector<ContentSuggestion> dismissed_suggestions =
-        content_suggestions_service_->GetDismissedSuggestionsForDebugging(
-            category);
 
     std::unique_ptr<base::ListValue> suggestions_list(new base::ListValue);
     for (const ContentSuggestion& suggestion : suggestions) {
       suggestions_list->Append(PrepareSuggestion(suggestion, index++));
     }
 
     std::unique_ptr<base::ListValue> dismissed_list(new base::ListValue);
-    for (const ContentSuggestion& suggestion : dismissed_suggestions) {
+    for (const ContentSuggestion& suggestion :
+         dismissed_suggestions_[category]) {
       dismissed_list->Append(PrepareSuggestion(suggestion, index++));
     }
 
     std::unique_ptr<base::DictionaryValue> category_entry(
         new base::DictionaryValue);
     category_entry->SetInteger("categoryId", category.id());
     category_entry->SetString(
         "dismissedContainerId",
         "dismissed-suggestions-" + base::IntToString(category.id()));
     category_entry->SetString("title", info->title());
@@ skipping 15 matching lines @@
 }
 
 void SnippetsInternalsMessageHandler::SendString(const std::string& name,
                                                  const std::string& value) {
   base::StringValue string_name(name);
   base::StringValue string_value(value);
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.SnippetsInternals.receiveProperty", string_name, string_value);
 }
+
+void SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded(
+    Category category,
+    std::vector<ContentSuggestion> dismissed_suggestions) {
+  if (dismissed_state_[category] == DismissedState::HIDDEN)
+    return;
+  dismissed_suggestions_[category] = std::move(dismissed_suggestions);
+  dismissed_state_[category] = DismissedState::VISIBLE;
+  SendContentSuggestions();
+}