Add more features to ntp-tiles-internal

components/ntp_tiles/webui/ntp_tiles_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 "components/ntp_tiles/webui/ntp_tiles_internals_message_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/files/file_util.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/task_runner_util.h"
 #include "base/values.h"
 #include "components/ntp_tiles/most_visited_sites.h"
 #include "components/ntp_tiles/pref_names.h"
 #include "components/ntp_tiles/webui/ntp_tiles_internals_message_handler_client.h"
 #include "components/prefs/pref_service.h"
 #include "components/url_formatter/url_fixer.h"
 #include "url/gurl.h"
 
 namespace ntp_tiles {
 
+namespace {
+
+base::Optional<std::string> ReadFileToString(const base::FilePath& path) {
+  std::string result;
+  if (!base::ReadFileToString(path, &result))
+    return base::Optional<std::string>();

[Marc Treib, 2016/12/15 10:29:17]

Could this just be "base::nullopt"?

[sfiera, 2017/02/02 17:16:44]

Could've, but this went away with today's simpler PopularSites interface.

+  return std::move(result);
+}
+
+std::string FormatJson(base::Optional<std::string> content) {
+  if (!content) {
+    return "(null)";
+  }
+
+  // If we can, parse it and pretty-print it, since it's minified on disk.
+  // Read JSON in-process, as this is just a debugging page.
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(*content);
+  if (value) {
+    std::string pretty_printed;
+    if (base::JSONWriter::WriteWithOptions(
+            *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty_printed)) {
+      return pretty_printed;
+    }
+  }
+
+  // By default, use the value as-is.
+  return *content;
+}
+
+}  // namespace
+
 NTPTilesInternalsMessageHandlerClient::NTPTilesInternalsMessageHandlerClient() =
     default;
 NTPTilesInternalsMessageHandlerClient::
     ~NTPTilesInternalsMessageHandlerClient() = default;
 
 NTPTilesInternalsMessageHandler::NTPTilesInternalsMessageHandler()
-    : client_(nullptr), site_count_(8) {}
+    : client_(nullptr), site_count_(8), weak_ptr_factory_(this) {}
 
 NTPTilesInternalsMessageHandler::~NTPTilesInternalsMessageHandler() = default;
 
 void NTPTilesInternalsMessageHandler::RegisterMessages(
     NTPTilesInternalsMessageHandlerClient* client) {
   client_ = client;
 
   client_->RegisterMessageCallback(
       "registerForEvents",
       base::Bind(&NTPTilesInternalsMessageHandler::HandleRegisterForEvents,
                  base::Unretained(this)));
 
   client_->RegisterMessageCallback(
       "update", base::Bind(&NTPTilesInternalsMessageHandler::HandleUpdate,
                            base::Unretained(this)));
+
+  client_->RegisterMessageCallback(
+      "fetchSuggestions",
+      base::Bind(&NTPTilesInternalsMessageHandler::HandleFetchSuggestions,
+                 base::Unretained(this)));
+
+  client_->RegisterMessageCallback(
+      "viewPopularSitesJson",
+      base::Bind(&NTPTilesInternalsMessageHandler::HandleViewPopularSitesJson,
+                 base::Unretained(this)));
 }
 
 void NTPTilesInternalsMessageHandler::HandleRegisterForEvents(
     const base::ListValue* args) {
   DCHECK(args->empty());
 
-  SendSourceInfo();
-
+  suggestions_status_.clear();
+  popular_sites_json_.clear();
   most_visited_sites_ = client_->MakeMostVisitedSites();
   most_visited_sites_->SetMostVisitedURLsObserver(this, site_count_);
+  SendSourceInfo();
 }
 
 void NTPTilesInternalsMessageHandler::HandleUpdate(
     const base::ListValue* args) {
   const base::DictionaryValue* dict = nullptr;
   DCHECK_EQ(1u, args->GetSize());
   args->GetDictionary(0, &dict);
   DCHECK(dict);
 
   PrefService* prefs = client_->GetPrefs();
 
-  if (client_->DoesSourceExist(ntp_tiles::NTPTileSource::POPULAR)) {
+  if (most_visited_sites_->DoesSourceExist(ntp_tiles::NTPTileSource::POPULAR)) {
+    popular_sites_json_.clear();
+
     std::string url;
     dict->GetString("popular.overrideURL", &url);
     if (url.empty()) {
       prefs->ClearPref(ntp_tiles::prefs::kPopularSitesOverrideURL);
     } else {
       prefs->SetString(ntp_tiles::prefs::kPopularSitesOverrideURL,
                        url_formatter::FixupURL(url, std::string()).spec());
     }
 
     std::string country;
@@ skipping 14 matching lines @@
   }
 
   // Recreate to pick up new values.
   // TODO(sfiera): refresh MostVisitedSites without re-creating it, as soon as
   // that will pick up changes to the Popular Sites overrides.
   most_visited_sites_ = client_->MakeMostVisitedSites();
   most_visited_sites_->SetMostVisitedURLsObserver(this, site_count_);
   SendSourceInfo();
 }
 
+void NTPTilesInternalsMessageHandler::HandleFetchSuggestions(
+    const base::ListValue* args) {
+  DCHECK_EQ(0u, args->GetSize());
+  if (!most_visited_sites_->DoesSourceExist(
+          ntp_tiles::NTPTileSource::SUGGESTIONS_SERVICE)) {
+    return;
+  }
+
+  if (most_visited_sites_->suggestions()->FetchSuggestionsData()) {
+    suggestions_status_ = "fetching...";
+  } else {
+    suggestions_status_ = "not synced";
+  }
+  SendSourceInfo();
+}
+
+void NTPTilesInternalsMessageHandler::HandleViewPopularSitesJson(
+    const base::ListValue* args) {
+  DCHECK_EQ(0u, args->GetSize());
+  if (!most_visited_sites_->DoesSourceExist(
+          ntp_tiles::NTPTileSource::POPULAR)) {
+    return;
+  }
+
+  const base::FilePath& path =
+      most_visited_sites_->popular_sites()->local_path();
+  base::PostTaskAndReplyWithResult(
+      client_->GetBlockingPool()
+          ->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
+          .get(),
+      FROM_HERE, base::Bind(&ReadFileToString, path),
+      base::Bind(&NTPTilesInternalsMessageHandler::PopularSitesJsonRead,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void NTPTilesInternalsMessageHandler::SendSourceInfo() {
   PrefService* prefs = client_->GetPrefs();
   base::DictionaryValue value;
 
-  value.SetBoolean("topSites",
-                   client_->DoesSourceExist(NTPTileSource::TOP_SITES));
-  value.SetBoolean(
-      "suggestionsService",
-      client_->DoesSourceExist(NTPTileSource::SUGGESTIONS_SERVICE));
-  value.SetBoolean("whitelist",
-                   client_->DoesSourceExist(NTPTileSource::WHITELIST));
+  value.SetBoolean("topSites", most_visited_sites_->DoesSourceExist(
+                                   NTPTileSource::TOP_SITES));
+  value.SetBoolean("whitelist", most_visited_sites_->DoesSourceExist(
+                                    NTPTileSource::WHITELIST));
 
-  if (client_->DoesSourceExist(NTPTileSource::POPULAR)) {
-    auto popular_sites = client_->MakePopularSites();
+  if (most_visited_sites_->DoesSourceExist(
+          NTPTileSource::SUGGESTIONS_SERVICE)) {
+    value.SetString("suggestionsService.status", suggestions_status_);
+  } else {
+    value.SetBoolean("suggestionsService", false);
+  }
+
+  if (most_visited_sites_->DoesSourceExist(NTPTileSource::POPULAR)) {
+    auto popular_sites = most_visited_sites_->popular_sites();
     value.SetString("popular.url", popular_sites->GetURLToUse().spec());
     value.SetString("popular.country", popular_sites->GetCountryToUse());
     value.SetString("popular.version", popular_sites->GetVersionToUse());
 
     value.SetString(
         "popular.overrideURL",
         prefs->GetString(ntp_tiles::prefs::kPopularSitesOverrideURL));
     value.SetString(
         "popular.overrideCountry",
         prefs->GetString(ntp_tiles::prefs::kPopularSitesOverrideCountry));
     value.SetString(
         "popular.overrideVersion",
         prefs->GetString(ntp_tiles::prefs::kPopularSitesOverrideVersion));
+
+    value.SetString("popular.json", popular_sites_json_);
   } else {
     value.SetBoolean("popular", false);
   }
 
   client_->CallJavascriptFunction(
       "chrome.ntp_tiles_internals.receiveSourceInfo", value);
 }
 
 void NTPTilesInternalsMessageHandler::SendTiles(const NTPTilesVector& tiles) {
   auto sites_list = base::MakeUnique<base::ListValue>();
   for (const NTPTile& tile : tiles) {
     auto entry = base::MakeUnique<base::DictionaryValue>();
     entry->SetString("title", tile.title);
     entry->SetString("url", tile.url.spec());
     entry->SetInteger("source", static_cast<int>(tile.source));
     entry->SetString("whitelistIconPath",
                      tile.whitelist_icon_path.LossyDisplayName());
     sites_list->Append(std::move(entry));
   }
 
   base::DictionaryValue result;
   result.Set("sites", std::move(sites_list));
   client_->CallJavascriptFunction("chrome.ntp_tiles_internals.receiveSites",
                                   result);
 }
 
+void NTPTilesInternalsMessageHandler::PopularSitesJsonRead(
+    const base::Optional<std::string>& content) {
+  popular_sites_json_ = FormatJson(content);
+  SendSourceInfo();
+}
+
 void NTPTilesInternalsMessageHandler::OnMostVisitedURLsAvailable(
     const NTPTilesVector& tiles) {
   SendTiles(tiles);
 }
 
 void NTPTilesInternalsMessageHandler::OnIconMadeAvailable(
     const GURL& site_url) {}
 
 }  // namespace ntp_tiles