[Query Tiles]: Prepare for exposing tile group data to WebUI.

- Move print string functions for Tile or TileGroup from test utils to
class member functions.
- Have GetTileGroupForTesting API internally, LogSource will read data
through this API, and then provide to logger's observer(WebUI).

Bug: 1066556
Change-Id: I7baff1cdc5b1e9d3bcebcc08f31d134a60470086
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2268886
Commit-Queue: Hesen Zhang <hesen@chromium.org>
Reviewed-by: Min Qin <qinmin@chromium.org>
Auto-Submit: Hesen Zhang <hesen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#784193}

components/query_tiles/internal/proto_conversion_unittest.cc

@@ -55,8 +55,8 @@ void TestTileConversion(Tile& expected) {
   TileFromProto(&proto, &actual);
   EXPECT_TRUE(test::AreTilesIdentical(expected, actual))
       << "actual: \n"
-      << test::DebugString(&actual) << "expected: \n"
-      << test::DebugString(&expected);
+      << actual.DebugString() << "expected: \n"
+      << expected.DebugString();
 }
 
 void TestTileGroupConversion(TileGroup& expected) {
@@ -66,8 +66,8 @@ void TestTileGroupConversion(TileGroup& expected) {
   TileGroupFromProto(&proto, &actual);
   EXPECT_TRUE(test::AreTileGroupsIdentical(expected, actual))
       << "actual: \n"
-      << test::DebugString(&actual) << "expected: \n"
-      << test::DebugString(&expected);
+      << actual.DebugString() << "expected: \n"
+      << expected.DebugString();
 }
 
 TEST(TileProtoConversionTest, TileConversions) {
@@ -92,7 +92,7 @@ TEST(TileProtoConversionTest, TileGroupFromResponseConversions) {
   server_response.SerializeToString(&server_response_str);
   EXPECT_EQ(tile_group.locale, "en") << std::endl
                                      << server_response_str << std::endl
-                                     << test::DebugString(&tile_group);
+                                     << tile_group.DebugString();
   TileIterator iter(tile_group, TileIterator::kAllTiles);
   size_t count = 0;
   while (iter.HasNext()) {
@@ -102,7 +102,7 @@ TEST(TileProtoConversionTest, TileGroupFromResponseConversions) {
     VerifySampleTileId(level, pos, next->id);
     count++;
   }
-  EXPECT_EQ(count, 12u) << test::DebugString(&tile_group);
+  EXPECT_EQ(count, 12u) << tile_group.DebugString();
 }
 
 }  // namespace

components/query_tiles/internal/tile_group.cc

@@ -4,6 +4,7 @@
 
 #include "components/query_tiles/internal/tile_group.h"
 
+#include <sstream>
 #include <utility>
 
 namespace query_tiles {
@@ -50,4 +51,14 @@ TileGroup& TileGroup::operator=(const TileGroup& other) {
 
 TileGroup& TileGroup::operator=(TileGroup&& other) = default;
 
+std::string TileGroup::DebugString() {
+  std::stringstream out;
+  out << "Group detail: \n";
+  out << "id: " << this->id << " | locale: " << this->locale
+      << " | last_updated_ts: " << this->last_updated_ts << " \n";
+  for (const auto& tile : this->tiles)
+    out << tile->DebugString();
+  return out.str();
+}
+
 }  // namespace query_tiles

components/query_tiles/internal/tile_group.h

@@ -39,6 +39,9 @@ struct TileGroup {
 
   // Top level tiles.
   std::vector<std::unique_ptr<Tile>> tiles;
+
+  // Print pretty formatted content in TileGroup struct.
+  std::string DebugString();
 };
 
 }  // namespace query_tiles

components/query_tiles/internal/tile_manager.cc

@@ -103,6 +103,11 @@ class TileManagerImpl : public TileManager {
     accept_languages_ = accept_languages;
   }
 
+  void GetTileGroupForTesting(TileGroup* tile_group) override {
+    if (tile_group_)
+      *tile_group = *tile_group_.get();
+  }
+
   void OnTileStoreInitialized(
       TileGroupStatusCallback callback,
       bool success,

components/query_tiles/internal/tile_manager.h

@@ -50,14 +50,16 @@ class TileManager {
   // Delete everything in db. Used for debugging and testing only.
   virtual TileGroupStatus PurgeDb() = 0;
 
-  virtual void SetAcceptLanguagesForTesting(
-      const std::string& accept_languages) = 0;
-
   TileManager();
   virtual ~TileManager() = default;
 
   TileManager(const TileManager& other) = delete;
   TileManager& operator=(const TileManager& other) = delete;
+
+  //-------Debug and Testing-----------------------------------------
+  virtual void GetTileGroupForTesting(TileGroup* group) = 0;
+  virtual void SetAcceptLanguagesForTesting(
+      const std::string& accept_languages) = 0;
 };
 
 }  // namespace query_tiles

components/query_tiles/internal/tile_manager_unittest.cc

@@ -337,6 +337,16 @@ TEST_F(TileManagerTest, PurgeDb) {
   GetTiles(std::vector<Tile>() /*expect an empty result*/);
 }
 
+TEST_F(TileManagerTest, GetTileGroup) {
+  TileGroup expected;
+  test::ResetTestGroup(&expected);
+  InitWithData(TileGroupStatus::kSuccess, {expected});
+
+  TileGroup actual;
+  manager()->GetTileGroupForTesting(&actual);
+  EXPECT_TRUE(test::AreTileGroupsIdentical(actual, expected));
+}
+
 }  // namespace
 
 }  // namespace query_tiles

components/query_tiles/internal/tile_service_impl_unittest.cc

@@ -6,6 +6,8 @@
 
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -37,6 +39,7 @@ class MockTileManager : public TileManager {
                void(std::unique_ptr<TileGroup>, TileGroupStatusCallback));
   MOCK_METHOD1(SetAcceptLanguagesForTesting, void(const std::string&));
   MOCK_METHOD0(PurgeDb, TileGroupStatus());
+  MOCK_METHOD1(GetTileGroupForTesting, void(TileGroup*));
 };
 
 class MockTileServiceScheduler : public TileServiceScheduler {

components/query_tiles/internal/tile_store_unittest.cc

@@ -80,8 +80,8 @@ class TileStoreTest : public testing::Test {
       auto& expected_group = expected->at(it->first);
       EXPECT_TRUE(
           test::AreTileGroupsIdentical(actual_loaded_group, expected_group))
-          << "\n Actual: " << test::DebugString(&actual_loaded_group)
-          << "\n Expected: " << test::DebugString(&expected_group);
+          << "\n Actual: " << actual_loaded_group.DebugString()
+          << "\n Expected: " << expected_group.DebugString();
     }
   }
 

components/query_tiles/test/test_utils.cc

@@ -5,12 +5,8 @@
 #include "components/query_tiles/test/test_utils.h"
 
 #include <algorithm>
-#include <deque>
-#include <map>
 #include <memory>
-#include <sstream>
 #include <utility>
-#include <vector>
 
 namespace query_tiles {
 namespace test {
@@ -19,65 +15,8 @@ namespace {
 
 const char kTimeStr[] = "03/18/20 01:00:00 AM";
 
-void SerializeEntry(const Tile* entry, std::stringstream& out) {
-  if (!entry)
-    return;
-  out << "entry id: " << entry->id << " query text: " << entry->query_text
-      << "  display text: " << entry->display_text
-      << "  accessibility_text: " << entry->accessibility_text << " \n";
-
-  for (const auto& image : entry->image_metadatas)
-    out << "image url: " << image.url.possibly_invalid_spec() << " \n";
-}
-
 }  // namespace
 
-std::string DebugString(const Tile* root) {
-  if (!root)
-    return std::string();
-  std::stringstream out;
-  out << "Entries detail: \n";
-  std::map<std::string, std::vector<std::string>> cache;
-  std::deque<const Tile*> queue;
-  queue.emplace_back(root);
-  while (!queue.empty()) {
-    size_t size = queue.size();
-    for (size_t i = 0; i < size; i++) {
-      auto* parent = queue.front();
-      SerializeEntry(parent, out);
-      queue.pop_front();
-      for (size_t j = 0; j < parent->sub_tiles.size(); j++) {
-        cache[parent->id].emplace_back(parent->sub_tiles[j]->id);
-        queue.emplace_back(parent->sub_tiles[j].get());
-      }
-    }
-  }
-  out << "Tree table: \n";
-  for (auto& pair : cache) {
-    std::string line;
-    line += pair.first + " : [";
-    std::sort(pair.second.begin(), pair.second.end());
-    for (const auto& child : pair.second)
-      line += " " + child;
-    line += " ]\n";
-    out << line;
-  }
-  return out.str();
-}
-
-std::string DebugString(const TileGroup* group) {
-  if (!group)
-    return std::string();
-  std::stringstream out;
-  out << "Group detail: \n";
-  out << "id: " << group->id << " locale: " << group->locale
-      << " last_updated_ts: " << group->last_updated_ts << " \n";
-  for (const auto& tile : group->tiles) {
-    out << DebugString(tile.get());
-  }
-  return out.str();
-}
-
 void ResetTestEntry(Tile* entry) {
   entry->id = "guid-1-1";
   entry->query_text = "test query str";

components/query_tiles/test/test_utils.h

@@ -14,13 +14,6 @@
 namespace query_tiles {
 namespace test {
 
-// Print data in Tile, also with tree represent by adjacent nodes
-// key-value[parent id: {children id}] pairs.
-std::string DebugString(const Tile* entry);
-
-// Print data in TileGroup.
-std::string DebugString(const TileGroup* group);
-
 // Build and reset the TileGroup for test usage.
 void ResetTestGroup(TileGroup* group);
 

components/query_tiles/tile.cc

@@ -4,6 +4,10 @@
 
 #include "components/query_tiles/tile.h"
 
+#include <algorithm>
+#include <deque>
+#include <map>
+#include <sstream>
 #include <utility>
 
 namespace query_tiles {
@@ -26,6 +30,50 @@ void DeepCopyTiles(const Tile& input, Tile* out) {
   }
 }
 
+void SerializeEntry(const Tile* entry, std::stringstream& out) {
+  if (!entry)
+    return;
+  out << "entry id: " << entry->id << " query text: " << entry->query_text
+      << "  display text: " << entry->display_text
+      << "  accessibility_text: " << entry->accessibility_text << " \n";
+
+  for (const auto& image : entry->image_metadatas)
+    out << "image url: " << image.url.possibly_invalid_spec() << " \n";
+}
+
+std::string DebugStringInternal(const Tile* root) {
+  if (!root)
+    return std::string();
+  std::stringstream out;
+  out << "Entries detail: \n";
+  std::map<std::string, std::vector<std::string>> cache;
+  std::deque<const Tile*> queue;
+  queue.emplace_back(root);
+  while (!queue.empty()) {
+    size_t size = queue.size();
+    for (size_t i = 0; i < size; i++) {
+      auto* parent = queue.front();
+      SerializeEntry(parent, out);
+      queue.pop_front();
+      for (size_t j = 0; j < parent->sub_tiles.size(); j++) {
+        cache[parent->id].emplace_back(parent->sub_tiles[j]->id);
+        queue.emplace_back(parent->sub_tiles[j].get());
+      }
+    }
+  }
+  out << "Tree table: \n";
+  for (auto& pair : cache) {
+    std::string line;
+    line += pair.first + " : [";
+    std::sort(pair.second.begin(), pair.second.end());
+    for (const auto& child : pair.second)
+      line += " " + child;
+    line += " ]\n";
+    out << line;
+  }
+  return out.str();
+}
+
 }  // namespace
 
 ImageMetadata::ImageMetadata() = default;
@@ -70,4 +118,8 @@ Tile& Tile::operator=(const Tile& other) {
 
 Tile& Tile::operator=(Tile&& other) noexcept = default;
 
+std::string Tile::DebugString() {
+  return DebugStringInternal(this);
+}
+
 }  // namespace query_tiles

components/query_tiles/tile.h

@@ -59,6 +59,9 @@ struct Tile {
 
   // Additional params for search query.
   std::vector<std::string> search_params;
+
+  // Print pretty formatted content in Tile struct.
+  std::string DebugString();
 };
 
 }  // namespace query_tiles