Only send the FrameSinkId to client when it is necessary

services/ui/ws/window_manager_client_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 202 matching lines @@
     window_ = nullptr;
   }
 
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTracker);
 };
 
 // Creates a new visible Window. If |parent| is non-null the newly created
 // window is added to it.
-aura::Window* NewVisibleWindow(aura::Window* parent,
-                               aura::WindowTreeClient* client) {
+aura::Window* NewVisibleWindow(
+    aura::Window* parent,
+    aura::WindowTreeClient* client,
+    aura::WindowMusType type = aura::WindowMusType::LOCAL) {
   std::unique_ptr<aura::WindowPortMus> window_port_mus =
-      base::MakeUnique<aura::WindowPortMus>(client, aura::WindowMusType::LOCAL);
+      base::MakeUnique<aura::WindowPortMus>(client, type);
   aura::Window* window = new aura::Window(nullptr, std::move(window_port_mus));
   window->Init(ui::LAYER_NOT_DRAWN);
   window->Show();
   if (parent)
     parent->AddChild(window);
   return window;
 }
 
 }  // namespace
 
@@ skipping 132 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WindowServerTest);
 };
 
 TEST_F(WindowServerTest, RootWindow) {
   ASSERT_NE(nullptr, window_manager());
   EXPECT_EQ(1u, window_manager()->GetRoots().size());
 }
 
 TEST_F(WindowServerTest, Embed) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
+#if 0

[sky, 2017/05/18 03:18:08]

How come you are commenting out this code?

[Peng, 2017/05/18 13:34:56]

I added it for debugging and forgot to remove it. Done

   ASSERT_TRUE(embed_result->IsValid());
 
   aura::Window* embed_root = embed_result->window_tree_host->window();
   // WindowTreeHost::window() is the single root of the embed.
   EXPECT_EQ(1u, embed_result->window_tree_client->GetRoots().size());
   EXPECT_EQ(embed_root, GetFirstRoot(embed_result->window_tree_client.get()));
   EXPECT_EQ(server_id(window), server_id(embed_root));
   EXPECT_EQ(nullptr, embed_root->parent());
   EXPECT_TRUE(embed_root->children().empty());
+#endif
 }
 
 // Window manager has two windows, N1 and N11. Embeds A at N1. A should not see
 // N11.
 TEST_F(WindowServerTest, EmbeddedDoesntSeeChild) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
   aura::Window* embed_root = embed_result->window_tree_host->window();
   EXPECT_EQ(server_id(window), server_id(embed_root));
   EXPECT_EQ(nullptr, embed_root->parent());
   EXPECT_TRUE(embed_root->children().empty());
 }
 
 // TODO(beng): write a replacement test for the one that once existed here:
 // This test validates the following scenario:
 // -  a window originating from one client
 // -  a window originating from a second client
 // +  the client originating the window is destroyed
 // -> the window should still exist (since the second client is live) but
 //    should be disconnected from any windows.
 // http://crbug.com/396300
 //
 // TODO(beng): The new test should validate the scenario as described above
 //             except that the second client still has a valid tree.
 
 // Verifies that bounds changes applied to a window hierarchy in one client
 // are reflected to another.
 TEST_F(WindowServerTest, SetBounds) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
   aura::Window* embed_root = embed_result->window_tree_host->window();
   EXPECT_EQ(window->bounds(), embed_root->bounds());
 
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   ASSERT_TRUE(WaitForBoundsToChange(embed_root));
   EXPECT_EQ(window->bounds(), embed_root->bounds());
 }
 
 // Verifies that bounds changes applied to a window owned by a different
 // client can be refused.
 TEST_F(WindowServerTest, SetBoundsSecurity) {
   TestWindowManagerDelegate wm_delegate;
   set_window_manager_delegate(&wm_delegate);
 
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
   aura::Window* embed_root = embed_result->window_tree_host->window();
   window->SetBounds(gfx::Rect(0, 0, 800, 600));
   ASSERT_TRUE(WaitForBoundsToChange(embed_root));
 
   embed_result->window_tree_host->SetBoundsInPixels(gfx::Rect(0, 0, 1024, 768));
   // Bounds change is initially accepted, but the server declines the request.
   EXPECT_NE(window->bounds(), embed_root->bounds());
 
   // The client is notified when the requested is declined, and updates the
   // local bounds accordingly.
   ASSERT_TRUE(WaitForBoundsToChange(embed_root));
   EXPECT_EQ(window->bounds(), embed_root->bounds());
   set_window_manager_delegate(nullptr);
 }
 
 // Verifies that a root window can always be destroyed.
 TEST_F(WindowServerTest, DestroySecurity) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
   aura::Window* embed_root = embed_result->window_tree_host->window();
 
   // The root can be destroyed, even though it was not created by the client.
   aura::WindowTracker tracker;
   tracker.Add(window);
   tracker.Add(embed_root);
   embed_result->window_tree_host.reset();
   EXPECT_FALSE(tracker.Contains(embed_root));
   EXPECT_TRUE(tracker.Contains(window));
 
   delete window;
   EXPECT_FALSE(tracker.Contains(window));
 }
 
 TEST_F(WindowServerTest, MultiRoots) {
-  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager());
-  aura::Window* window2 = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                           aura::WindowMusType::EMBED_IN_OWNER);
+  aura::Window* window2 = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                           aura::WindowMusType::EMBED_IN_OWNER);
   std::unique_ptr<EmbedResult> embed_result1 = Embed(window_manager(), window1);
   ASSERT_TRUE(embed_result1->IsValid());
   std::unique_ptr<EmbedResult> embed_result2 = Embed(window_manager(), window2);
   ASSERT_TRUE(embed_result2->IsValid());
 }
 
 TEST_F(WindowServerTest, Reorder) {
-  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                           aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window1);
   ASSERT_TRUE(embed_result->IsValid());
   aura::WindowTreeClient* embedded = embed_result->window_tree_client.get();
   aura::Window* embed_root = embed_result->window_tree_host->window();
 
   aura::Window* window11 = NewVisibleWindow(embed_root, embedded);
   aura::Window* window12 = NewVisibleWindow(embed_root, embedded);
   ASSERT_TRUE(WaitForTreeSizeToMatch(window1, 3u));
 
@@ skipping 56 matching lines @@
   }
 
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(WindowServerTest, Visible) {
-  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                           aura::WindowMusType::EMBED_IN_OWNER);
 
   // Embed another app and verify initial state.
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window1);
   ASSERT_TRUE(embed_result->IsValid());
   aura::Window* embed_root = embed_result->window_tree_host->window();
   EXPECT_TRUE(embed_root->TargetVisibility());
   EXPECT_TRUE(embed_root->IsVisible());
 
   // Change the visible state from the first client and verify its mirrored
   // correctly to the embedded app.
@@ skipping 20 matching lines @@
   EXPECT_TRUE(window1->IsVisible());
 
   EXPECT_TRUE(embed_root->TargetVisibility());
   EXPECT_TRUE(embed_root->IsVisible());
 }
 
 // TODO(beng): tests for window event dispatcher.
 // - verify that we see events for all windows.
 
 TEST_F(WindowServerTest, EmbedFailsWithChildren) {
-  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window1 = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                           aura::WindowMusType::EMBED_IN_OWNER);
   ASSERT_TRUE(NewVisibleWindow(window1, window_manager()));
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window1);
   // Embed() should fail as |window1| has a child.
   EXPECT_FALSE(embed_result->IsValid());
 }
 
 namespace {
 
 class DestroyObserver : public aura::WindowObserver {
  public:
@@ skipping 16 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a Window that is the root of another client notifies
 // observers in the right order (OnWindowDestroyed() before
 // OnWindowManagerDestroyed()).
 TEST_F(WindowServerTest, WindowServerDestroyedAfterRootObserver) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
   aura::WindowTreeClient* embedded_client =
       embed_result->window_tree_client.get();
 
   bool got_destroy = false;
   DestroyObserver observer(embedded_client, &got_destroy);
   // Delete the window |embedded_client| is embedded in. |embedded_client| is
   // asynchronously notified and cleans up.
   delete window;
   EXPECT_TRUE(DoRunLoopWithTimeout());
   ASSERT_TRUE(got_destroy);
   // The WindowTreeHost was destroyed as well (by
   // WindowServerTestBase::OnEmbedRootDestroyed()).
   embed_result->window_tree_host.release();
   EXPECT_EQ(0u, embed_result->window_tree_client->GetRoots().size());
 }
 
 TEST_F(WindowServerTest, ClientAreaChanged) {
-  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager());
+  aura::Window* window = NewVisibleWindow(GetFirstWMRoot(), window_manager(),
+                                          aura::WindowMusType::EMBED_IN_OWNER);
 
   std::unique_ptr<EmbedResult> embed_result = Embed(window_manager(), window);
   ASSERT_TRUE(embed_result->IsValid());
 
   // Verify change from embedded makes it to parent.
   const gfx::Insets insets(1, 2, 3, 4);
   embed_result->window_tree_host->SetClientArea(insets,
                                                 std::vector<gfx::Rect>());
   std::unique_ptr<ClientAreaChange> client_area_change =
       WaitForClientAreaToChange();
@@ skipping 18 matching lines @@
     run_loop_.reset();
     return created_window_ != nullptr;
   }
 
   aura::Window* created_window() { return created_window_; }
 
   // WindowManagerDelegate:
   aura::Window* OnWmCreateTopLevelWindow(
       ui::mojom::WindowType window_type,
       std::map<std::string, std::vector<uint8_t>>* properties) override {
-    created_window_ = NewVisibleWindow((*client_->GetRoots().begin()), client_);
+    created_window_ = NewVisibleWindow((*client_->GetRoots().begin()), client_,
+                                       aura::WindowMusType::TOP_LEVEL_IN_WM);
     if (run_loop_)
       run_loop_->Quit();
     return created_window_;
   }
 
  private:
   aura::WindowTreeClient* client_;
   std::unique_ptr<base::RunLoop> run_loop_;
   aura::Window* created_window_;
 
@@ skipping 62 matching lines @@
   ASSERT_EQ(1u, top_level_in_wm->children().size());
   aura::Window* second_client_child_in_wm = top_level_in_wm->children()[0];
   ASSERT_EQ(1u, second_client_child_in_wm->children().size());
   aura::Window* transient_in_wm = second_client_child_in_wm->children()[0];
   ASSERT_EQ(second_client_child_in_wm,
             transient_window_client->GetTransientParent(transient_in_wm));
 }
 
 }  // namespace ws
 }  // namespace ui