Extending the UserClassifier to actually support classification.

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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "chrome/browser/ntp_snippets/content_suggestions_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/ntp_snippet.h"
 #include "components/ntp_snippets/switches.h"
 #include "content/public/browser/web_ui.h"
 
 using ntp_snippets::ContentSuggestion;
 using ntp_snippets::Category;
 using ntp_snippets::CategoryInfo;
 using ntp_snippets::CategoryStatus;
 using ntp_snippets::KnownCategories;
+using ntp_snippets::UserClassifier;
 
 namespace {
 
 std::unique_ptr<base::DictionaryValue> PrepareSuggestion(
     const ContentSuggestion& suggestion,
     int index) {
   auto entry = base::MakeUnique<base::DictionaryValue>();
   entry->SetString("suggestionId", suggestion.id());
   entry->SetString("url", suggestion.url().spec());
   entry->SetString("ampUrl", suggestion.amp_url().spec());
@@ skipping 21 matching lines @@
     case CategoryStatus::CATEGORY_EXPLICITLY_DISABLED:
       return "CATEGORY_EXPLICITLY_DISABLED";
     case CategoryStatus::SIGNED_OUT:
       return "SIGNED_OUT";
     case CategoryStatus::LOADING_ERROR:
       return "LOADING_ERROR";
   }
   return std::string();
 }
 
-} // namespace
+}  // namespace
 
 SnippetsInternalsMessageHandler::SnippetsInternalsMessageHandler()
     : content_suggestions_service_observer_(this),
       dom_loaded_(false),
       ntp_snippets_service_(nullptr),
       content_suggestions_service_(nullptr),
       weak_ptr_factory_(this) {}
 
 SnippetsInternalsMessageHandler::~SnippetsInternalsMessageHandler() {}
 
@@ skipping 25 matching lines @@
       "clearDismissedSuggestions",
       base::Bind(
           &SnippetsInternalsMessageHandler::HandleClearDismissedSuggestions,
           base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "toggleDismissedSuggestions",
       base::Bind(
           &SnippetsInternalsMessageHandler::HandleToggleDismissedSuggestions,
           base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "clearClassification",
+      base::Bind(
+          &SnippetsInternalsMessageHandler::ClearClassification,
+          base::Unretained(this)));
 }
 
 void SnippetsInternalsMessageHandler::OnNewSuggestions(Category category) {
   if (!dom_loaded_)
     return;
   SendContentSuggestions();
 }
 
 void SnippetsInternalsMessageHandler::OnCategoryStatusChanged(
     Category category,
@@ skipping 106 matching lines @@
         category,
         base::Bind(
             &SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded,
             weak_ptr_factory_.GetWeakPtr(), category));
   } else {
     dismissed_state_[category] = DismissedState::HIDDEN;
     dismissed_suggestions_[category].clear();
   }
 }
 
+void SnippetsInternalsMessageHandler::ClearClassification(
+    const base::ListValue* args) {
+  DCHECK_EQ(0u, args->GetSize());
+  content_suggestions_service_->user_classifier()
+      ->ClearClassificationForDebugging();
+  SendClassification();
+}
+
 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));
   SendBoolean(
       "flag-download-suggestions",
       base::FeatureList::IsEnabled(ntp_snippets::kDownloadSuggestionsFeature));
   SendBoolean(
       "flag-bookmark-suggestions",
       base::FeatureList::IsEnabled(ntp_snippets::kBookmarkSuggestionsFeature));
 
   SendBoolean("flag-physical-web-page-suggestions",
               base::FeatureList::IsEnabled(
                   ntp_snippets::kPhysicalWebPageSuggestionsFeature));
 
+  SendClassification();
+
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.SnippetsInternals.setHostRestricted",
       base::FundamentalValue(
           ntp_snippets_service_->snippets_fetcher()->UsesHostRestrictions()));
 
   switch (ntp_snippets_service_->snippets_fetcher()->personalization()) {
     case ntp_snippets::NTPSnippetsFetcher::Personalization::kPersonal:
       SendString("switch-personalized", "Only personalized");
       break;
     case ntp_snippets::NTPSnippetsFetcher::Personalization::kBoth:
       SendString("switch-personalized",
                  "Both personalized and non-personalized");
       break;
     case ntp_snippets::NTPSnippetsFetcher::Personalization::kNonPersonal:
       SendString("switch-personalized", "Only non-personalized");
       break;
   }
 
   SendString("switch-fetch-url",
              ntp_snippets_service_->snippets_fetcher()->fetch_url().spec());
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.SnippetsInternals.receiveJson",
       base::StringValue(
           ntp_snippets_service_->snippets_fetcher()->last_json()));
 
   SendContentSuggestions();
 }
 
+void SnippetsInternalsMessageHandler::SendClassification() {
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "chrome.SnippetsInternals.receiveClassification",
+      base::StringValue(content_suggestions_service_->user_classifier()
+                            ->GetUserClassDescriptionForDebugging()),
+      base::FundamentalValue(
+          content_suggestions_service_->user_classifier()->GetEstimatedAvgTime(
+              UserClassifier::Metric::NTP_OPENED)),
+      base::FundamentalValue(
+          content_suggestions_service_->user_classifier()->GetEstimatedAvgTime(
+              UserClassifier::Metric::SUGGESTIONS_SHOWN)),
+      base::FundamentalValue(
+          content_suggestions_service_->user_classifier()->GetEstimatedAvgTime(
+              UserClassifier::Metric::SUGGESTIONS_USED)));
+}
+
 void SnippetsInternalsMessageHandler::SendHosts() {
   std::unique_ptr<base::ListValue> hosts_list(new base::ListValue);
 
   std::set<std::string> hosts = ntp_snippets_service_->GetSuggestionsHosts();
 
   for (const std::string& host : hosts) {
     std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
     entry->SetString("url", host);
 
     hosts_list->Append(std::move(entry));
@@ skipping 69 matching lines @@
 
 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();
 }