Fixes problems with drawn state

components/mus/ws/test_change_tracker.cc

 // Copyright 2014 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/mus/ws/test_change_tracker.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 16 matching lines @@
 
 std::string RectToString(const mojo::Rect& rect) {
   return base::StringPrintf("%d,%d %dx%d", rect.x, rect.y, rect.width,
                             rect.height);
 }
 
 std::string DirectionToString(mojom::OrderDirection direction) {
   return direction == mojom::OrderDirection::ABOVE ? "above" : "below";
 }
 
-std::string ChangeToDescription1(const Change& change) {
+enum class ChangeDescriptionType {
+  ONE,
+  TWO,
+};
+
+std::string ChangeToDescription(const Change& change,
+                                ChangeDescriptionType type) {
   switch (change.type) {
     case CHANGE_TYPE_EMBED:
-      return "OnEmbed";
+      if (type == ChangeDescriptionType::ONE)
+        return "OnEmbed";
+      return base::StringPrintf("OnEmbed drawn=%s",
+                                change.bool_value ? "true" : "false");
 
     case CHANGE_TYPE_EMBEDDED_APP_DISCONNECTED:
       return base::StringPrintf("OnEmbeddedAppDisconnected window=%s",
                                 WindowIdToString(change.window_id).c_str());
 
     case CHANGE_TYPE_UNEMBED:
       return base::StringPrintf("OnUnembed window=%s",
                                 WindowIdToString(change.window_id).c_str());
 
     case CHANGE_TYPE_LOST_CAPTURE:
@@ skipping 67 matching lines @@
     case CHANGE_TYPE_CURSOR_CHANGED:
       return base::StringPrintf("CursorChanged id=%s cursor_id=%d",
                                 WindowIdToString(change.window_id).c_str(),
                                 change.cursor_id);
     case CHANGE_TYPE_ON_CHANGE_COMPLETED:
       return base::StringPrintf("ChangeCompleted id=%d sucess=%s",
                                 change.change_id,
                                 change.bool_value ? "true" : "false");
 
     case CHANGE_TYPE_ON_TOP_LEVEL_CREATED:
-      return base::StringPrintf("TopLevelCreated id=%d window_id=%s",
+      return base::StringPrintf("TopLevelCreated id=%d window_id=%s drawn=%s",
                                 change.change_id,
-                                WindowIdToString(change.window_id).c_str());
+                                WindowIdToString(change.window_id).c_str(),
+                                change.bool_value ? "true" : "false");
   }
   return std::string();
 }
 
+std::string SingleChangeToDescriptionImpl(const std::vector<Change>& changes,
+                                          ChangeDescriptionType change_type) {
+  std::string result;
+  for (auto& change : changes) {
+    if (!result.empty())
+      result += "\n";
+    result += ChangeToDescription(change, change_type);
+  }
+  return result;
+}
+
 }  // namespace
 
 std::vector<std::string> ChangesToDescription1(
     const std::vector<Change>& changes) {
   std::vector<std::string> strings(changes.size());
   for (size_t i = 0; i < changes.size(); ++i)
-    strings[i] = ChangeToDescription1(changes[i]);
+    strings[i] = ChangeToDescription(changes[i], ChangeDescriptionType::ONE);
   return strings;
 }
 
 std::string SingleChangeToDescription(const std::vector<Change>& changes) {
-  std::string result;
-  for (auto& change : changes) {
-    if (!result.empty())
-      result += "\n";
-    result += ChangeToDescription1(change);
-  }
-  return result;
+  return SingleChangeToDescriptionImpl(changes, ChangeDescriptionType::ONE);
+}
+
+std::string SingleChangeToDescription2(const std::vector<Change>& changes) {
+  return SingleChangeToDescriptionImpl(changes, ChangeDescriptionType::TWO);
 }
 
 std::string SingleWindowDescription(const std::vector<TestWindow>& windows) {
   if (windows.empty())
     return "no windows";
   std::string result;
   for (const TestWindow& window : windows)
     result += window.ToString();
   return result;
 }
 
 std::string ChangeWindowDescription(const std::vector<Change>& changes) {
   if (changes.size() != 1)
     return std::string();
   std::vector<std::string> window_strings(changes[0].windows.size());
   for (size_t i = 0; i < changes[0].windows.size(); ++i)
     window_strings[i] = "[" + changes[0].windows[i].ToString() + "]";
   return base::JoinString(window_strings, ",");
 }
 
 TestWindow WindowDataToTestWindow(const mojom::WindowDataPtr& data) {
   TestWindow window;
   window.parent_id = data->parent_id;
   window.window_id = data->window_id;
   window.visible = data->visible;
-  window.drawn = data->drawn;
   window.properties =
       data->properties.To<std::map<std::string, std::vector<uint8_t>>>();
   return window;
 }
 
 void WindowDatasToTestWindows(const Array<mojom::WindowDataPtr>& data,
                               std::vector<TestWindow>* test_windows) {
   for (size_t i = 0; i < data.size(); ++i)
     test_windows->push_back(WindowDataToTestWindow(data[i]));
 }
@@ skipping 11 matching lines @@
 
 Change::Change(const Change& other) = default;
 
 Change::~Change() {}
 
 TestChangeTracker::TestChangeTracker() : delegate_(NULL) {}
 
 TestChangeTracker::~TestChangeTracker() {}
 
 void TestChangeTracker::OnEmbed(ConnectionSpecificId connection_id,
-                                mojom::WindowDataPtr root) {
+                                mojom::WindowDataPtr root,
+                                bool drawn) {
   Change change;
   change.type = CHANGE_TYPE_EMBED;
   change.connection_id = connection_id;
+  change.bool_value = drawn;
   change.windows.push_back(WindowDataToTestWindow(root));
   AddChange(change);
 }
 
 void TestChangeTracker::OnEmbeddedAppDisconnected(Id window_id) {
   Change change;
   change.type = CHANGE_TYPE_EMBEDDED_APP_DISCONNECTED;
   change.window_id = window_id;
   AddChange(change);
 }
@@ skipping 89 matching lines @@
 }
 
 void TestChangeTracker::OnWindowVisibilityChanged(Id window_id, bool visible) {
   Change change;
   change.type = CHANGE_TYPE_NODE_VISIBILITY_CHANGED;
   change.window_id = window_id;
   change.bool_value = visible;
   AddChange(change);
 }
 
-void TestChangeTracker::OnWindowDrawnStateChanged(Id window_id, bool drawn) {
+void TestChangeTracker::OnWindowParentDrawnStateChanged(Id window_id,
+                                                        bool drawn) {
   Change change;
   change.type = CHANGE_TYPE_NODE_DRAWN_STATE_CHANGED;
   change.window_id = window_id;
   change.bool_value = drawn;
   AddChange(change);
 }
 
 void TestChangeTracker::OnWindowInputEvent(Id window_id,
                                            mojom::EventPtr event) {
   Change change;
@@ skipping 36 matching lines @@
 
 void TestChangeTracker::OnChangeCompleted(uint32_t change_id, bool success) {
   Change change;
   change.type = CHANGE_TYPE_ON_CHANGE_COMPLETED;
   change.change_id = change_id;
   change.bool_value = success;
   AddChange(change);
 }
 
 void TestChangeTracker::OnTopLevelCreated(uint32_t change_id,
-                                          mojom::WindowDataPtr window_data) {
+                                          mojom::WindowDataPtr window_data,
+                                          bool drawn) {
   Change change;
   change.type = CHANGE_TYPE_ON_TOP_LEVEL_CREATED;
   change.change_id = change_id;
   change.window_id = window_data->window_id;
+  change.bool_value = drawn;
   AddChange(change);
 }
 
 void TestChangeTracker::AddChange(const Change& change) {
   changes_.push_back(change);
   if (delegate_)
     delegate_->OnChangeAdded();
 }
 
 TestWindow::TestWindow() {}
 
 TestWindow::TestWindow(const TestWindow& other) = default;
 
 TestWindow::~TestWindow() {}
 
 std::string TestWindow::ToString() const {
   return base::StringPrintf("window=%s parent=%s",
                             WindowIdToString(window_id).c_str(),
                             WindowIdToString(parent_id).c_str());
 }
 
 std::string TestWindow::ToString2() const {
   return base::StringPrintf(
-      "window=%s parent=%s visible=%s drawn=%s",
-      WindowIdToString(window_id).c_str(), WindowIdToString(parent_id).c_str(),
-      visible ? "true" : "false", drawn ? "true" : "false");
+      "window=%s parent=%s visible=%s", WindowIdToString(window_id).c_str(),
+      WindowIdToString(parent_id).c_str(), visible ? "true" : "false");
 }
 
 }  // namespace ws
 
 }  // namespace mus