components/view_manager/view_manager_service_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/message_loop/message_loop.h"
   9 #include "components/view_manager/client_connection.h"
  10 #include "components/view_manager/connection_manager.h"
  11 #include "components/view_manager/connection_manager_delegate.h"
  12 #include "components/view_manager/display_manager.h"
  13 #include "components/view_manager/display_manager_factory.h"
  14 #include "components/view_manager/ids.h"
  15 #include "components/view_manager/public/cpp/types.h"
  16 #include "components/view_manager/public/cpp/util.h"
  17 #include "components/view_manager/public/interfaces/view_manager.mojom.h"
  18 #include "components/view_manager/server_view.h"
  19 #include "components/view_manager/surfaces/surfaces_state.h"
  20 #include "components/view_manager/test_change_tracker.h"
  21 #include "components/view_manager/view_manager_root_connection.h"
  22 #include "components/view_manager/view_manager_service_impl.h"
  23 #include "mojo/application/public/interfaces/service_provider.mojom.h"
  24 #include "mojo/converters/geometry/geometry_type_converters.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "ui/gfx/geometry/rect.h"
  27
  28 using mojo::Array;
  29 using mojo::ERROR_CODE_NONE;
  30 using mojo::InterfaceRequest;
  31 using mojo::ServiceProvider;
  32 using mojo::ServiceProviderPtr;
  33 using mojo::String;
  34 using mojo::ViewDataPtr;
  35
  36 namespace view_manager {
  37 namespace {
  38
  39 // -----------------------------------------------------------------------------
  40
  41 // ViewManagerClient implementation that logs all calls to a TestChangeTracker.
  42 // TODO(sky): refactor so both this and ViewManagerServiceAppTest share code.
  43 class TestViewManagerClient : public mojo::ViewManagerClient {
  44  public:
  45   TestViewManagerClient() {}
  46   ~TestViewManagerClient() override {}
  47
  48   TestChangeTracker* tracker() { return &tracker_; }
  49
  50  private:
  51   // ViewManagerClient:
  52   void OnEmbed(uint16_t connection_id,
  53                ViewDataPtr root,
  54                mojo::ViewManagerServicePtr view_manager_service,
  55                mojo::Id focused_view_id) override {
  56     // TODO(sky): add test coverage of |focused_view_id|.
  57     tracker_.OnEmbed(connection_id, root.Pass());
  58   }
  59   void OnEmbedForDescendant(
  60       uint32_t view,
  61       mojo::URLRequestPtr request,
  62       const OnEmbedForDescendantCallback& callback) override {}
  63   void OnEmbeddedAppDisconnected(uint32_t view) override {
  64     tracker_.OnEmbeddedAppDisconnected(view);
  65   }
  66   void OnUnembed() override { tracker_.OnUnembed(); }
  67   void OnViewBoundsChanged(uint32_t view,
  68                            mojo::RectPtr old_bounds,
  69                            mojo::RectPtr new_bounds) override {
  70     tracker_.OnViewBoundsChanged(view, old_bounds.Pass(), new_bounds.Pass());
  71   }
  72   void OnViewViewportMetricsChanged(
  73       mojo::ViewportMetricsPtr old_metrics,
  74       mojo::ViewportMetricsPtr new_metrics) override {
  75     tracker_.OnViewViewportMetricsChanged(old_metrics.Pass(),
  76                                           new_metrics.Pass());
  77   }
  78   void OnViewHierarchyChanged(uint32_t view,
  79                               uint32_t new_parent,
  80                               uint32_t old_parent,
  81                               Array<ViewDataPtr> views) override {
  82     tracker_.OnViewHierarchyChanged(view, new_parent, old_parent, views.Pass());
  83   }
  84   void OnViewReordered(uint32_t view_id,
  85                        uint32_t relative_view_id,
  86                        mojo::OrderDirection direction) override {
  87     tracker_.OnViewReordered(view_id, relative_view_id, direction);
  88   }
  89   void OnViewDeleted(uint32_t view) override { tracker_.OnViewDeleted(view); }
  90   void OnViewVisibilityChanged(uint32_t view, bool visible) override {
  91     tracker_.OnViewVisibilityChanged(view, visible);
  92   }
  93   void OnViewDrawnStateChanged(uint32_t view, bool drawn) override {
  94     tracker_.OnViewDrawnStateChanged(view, drawn);
  95   }
  96   void OnViewSharedPropertyChanged(uint32_t view,
  97                                    const String& name,
  98                                    Array<uint8_t> new_data) override {
  99     tracker_.OnViewSharedPropertyChanged(view, name, new_data.Pass());
 100   }
 101   void OnViewInputEvent(uint32_t view,
 102                         mojo::EventPtr event,
 103                         const mojo::Callback<void()>& callback) override {
 104     tracker_.OnViewInputEvent(view, event.Pass());
 105   }
 106   void OnViewFocused(uint32_t focused_view_id) override {
 107     tracker_.OnViewFocused(focused_view_id);
 108   }
 109
 110   TestChangeTracker tracker_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClient);
 113 };
 114
 115 // -----------------------------------------------------------------------------
 116
 117 // ClientConnection implementation that vends TestViewManagerClient.
 118 class TestClientConnection : public ClientConnection {
 119  public:
 120   explicit TestClientConnection(scoped_ptr<ViewManagerServiceImpl> service_impl)
 121       : ClientConnection(service_impl.Pass(), &client_) {}
 122
 123   TestViewManagerClient* client() { return &client_; }
 124
 125  private:
 126   ~TestClientConnection() override {}
 127
 128   TestViewManagerClient client_;
 129
 130   DISALLOW_COPY_AND_ASSIGN(TestClientConnection);
 131 };
 132
 133 // -----------------------------------------------------------------------------
 134
 135 // Empty implementation of ConnectionManagerDelegate.
 136 class TestConnectionManagerDelegate : public ConnectionManagerDelegate {
 137  public:
 138   TestConnectionManagerDelegate() : last_connection_(nullptr) {}
 139   ~TestConnectionManagerDelegate() override {}
 140
 141   TestViewManagerClient* last_client() {
 142     return last_connection_ ? last_connection_->client() : nullptr;
 143   }
 144
 145   TestClientConnection* last_connection() { return last_connection_; }
 146
 147  private:
 148   // ConnectionManagerDelegate:
 149   void OnNoMoreRootConnections() override {}
 150
 151   ClientConnection* CreateClientConnectionForEmbedAtView(
 152       ConnectionManager* connection_manager,
 153       mojo::InterfaceRequest<mojo::ViewManagerService> service_request,
 154       mojo::ConnectionSpecificId creator_id,
 155       mojo::URLRequestPtr request,
 156       const ViewId& root_id) override {
 157     scoped_ptr<ViewManagerServiceImpl> service(
 158         new ViewManagerServiceImpl(connection_manager, creator_id, root_id));
 159     last_connection_ = new TestClientConnection(service.Pass());
 160     return last_connection_;
 161   }
 162   ClientConnection* CreateClientConnectionForEmbedAtView(
 163       ConnectionManager* connection_manager,
 164       mojo::InterfaceRequest<mojo::ViewManagerService> service_request,
 165       mojo::ConnectionSpecificId creator_id,
 166       const ViewId& root_id,
 167       mojo::ViewManagerClientPtr client) override {
 168     // Used by ConnectionManager::AddRoot.
 169     scoped_ptr<ViewManagerServiceImpl> service(
 170         new ViewManagerServiceImpl(connection_manager, creator_id, root_id));
 171     last_connection_ = new TestClientConnection(service.Pass());
 172     return last_connection_;
 173   }
 174
 175   TestClientConnection* last_connection_;
 176
 177   DISALLOW_COPY_AND_ASSIGN(TestConnectionManagerDelegate);
 178 };
 179
 180 // -----------------------------------------------------------------------------
 181
 182 class TestViewManagerRootConnection : public ViewManagerRootConnection {
 183  public:
 184   TestViewManagerRootConnection(scoped_ptr<ViewManagerRootImpl> root,
 185                                 ConnectionManager* manager)
 186       : ViewManagerRootConnection(root.Pass(), manager) {}
 187   ~TestViewManagerRootConnection() override {}
 188
 189  private:
 190   // ViewManagerRootDelegate:
 191   void OnDisplayInitialized() override {
 192     connection_manager()->AddRoot(this);
 193     set_view_manager_service(connection_manager()->EmbedAtView(
 194         kInvalidConnectionId,
 195         view_manager_root()->root_view()->id(),
 196         mojo::ViewManagerClientPtr()));
 197   }
 198   DISALLOW_COPY_AND_ASSIGN(TestViewManagerRootConnection);
 199 };
 200
 201 // -----------------------------------------------------------------------------
 202 // Empty implementation of DisplayManager.
 203 class TestDisplayManager : public DisplayManager {
 204  public:
 205   TestDisplayManager() {}
 206   ~TestDisplayManager() override {}
 207
 208   // DisplayManager:
 209   void Init(DisplayManagerDelegate* delegate) override {
 210     // It is necessary to tell the delegate about the ViewportMetrics to make
 211     // sure that the ViewManagerRootConnection is correctly initialized (and a
 212     // root-view is created).
 213     mojo::ViewportMetrics metrics;
 214     metrics.size_in_pixels = mojo::Size::From(gfx::Size(400, 300));
 215     metrics.device_pixel_ratio = 1.f;
 216     delegate->OnViewportMetricsChanged(mojo::ViewportMetrics(), metrics);
 217   }
 218   void SchedulePaint(const ServerView* view, const gfx::Rect& bounds) override {
 219   }
 220   void SetViewportSize(const gfx::Size& size) override {}
 221   const mojo::ViewportMetrics& GetViewportMetrics() override {
 222     return display_metrices_;
 223   }
 224   void UpdateTextInputState(const ui::TextInputState& state) override {}
 225   void SetImeVisibility(bool visible) override {}
 226
 227  private:
 228   mojo::ViewportMetrics display_metrices_;
 229
 230   DISALLOW_COPY_AND_ASSIGN(TestDisplayManager);
 231 };
 232
 233 // Factory that dispenses TestDisplayManagers.
 234 class TestDisplayManagerFactory : public DisplayManagerFactory {
 235  public:
 236   TestDisplayManagerFactory() {}
 237   ~TestDisplayManagerFactory() {}
 238   DisplayManager* CreateDisplayManager(
 239       bool is_headless,
 240       mojo::ApplicationImpl* app_impl,
 241       const scoped_refptr<gles2::GpuState>& gpu_state,
 242       const scoped_refptr<surfaces::SurfacesState>& surfaces_state) override {
 243     return new TestDisplayManager();
 244   }
 245
 246  private:
 247   DISALLOW_COPY_AND_ASSIGN(TestDisplayManagerFactory);
 248 };
 249
 250 mojo::EventPtr CreatePointerDownEvent(int x, int y) {
 251   mojo::EventPtr event(mojo::Event::New());
 252   event->action = mojo::EVENT_TYPE_POINTER_DOWN;
 253   event->pointer_data = mojo::PointerData::New();
 254   event->pointer_data->pointer_id = 1u;
 255   event->pointer_data->x = x;
 256   event->pointer_data->y = y;
 257   return event.Pass();
 258 }
 259
 260 mojo::EventPtr CreatePointerUpEvent(int x, int y) {
 261   mojo::EventPtr event(mojo::Event::New());
 262   event->action = mojo::EVENT_TYPE_POINTER_UP;
 263   event->pointer_data = mojo::PointerData::New();
 264   event->pointer_data->pointer_id = 1u;
 265   event->pointer_data->x = x;
 266   event->pointer_data->y = y;
 267   return event.Pass();
 268 }
 269
 270 }  // namespace
 271
 272 // -----------------------------------------------------------------------------
 273
 274 class ViewManagerServiceTest : public testing::Test {
 275  public:
 276   ViewManagerServiceTest() : wm_client_(nullptr) {}
 277   ~ViewManagerServiceTest() override {}
 278
 279   // ViewManagerServiceImpl for the window manager.
 280   ViewManagerServiceImpl* wm_connection() {
 281     return connection_manager_->GetConnection(1);
 282   }
 283
 284   TestViewManagerClient* last_view_manager_client() {
 285     return delegate_.last_client();
 286   }
 287
 288   TestClientConnection* last_client_connection() {
 289     return delegate_.last_connection();
 290   }
 291
 292   ConnectionManager* connection_manager() { return connection_manager_.get(); }
 293
 294   TestViewManagerClient* wm_client() { return wm_client_; }
 295
 296   TestViewManagerRootConnection* root_connection() { return root_connection_; }
 297
 298  protected:
 299   // testing::Test:
 300   void SetUp() override {
 301     DisplayManager::set_factory_for_testing(&display_manager_factory_);
 302     // TODO(fsamuel): This is probably broken. We need a root.
 303     connection_manager_.reset(new ConnectionManager(&delegate_));
 304     ViewManagerRootImpl* root = new ViewManagerRootImpl(
 305         connection_manager_.get(), true /* is_headless */, nullptr,
 306         scoped_refptr<gles2::GpuState>(),
 307         scoped_refptr<surfaces::SurfacesState>());
 308     // TODO(fsamuel): This is way too magical. We need to find a better way to
 309     // manage lifetime.
 310     root_connection_ = new TestViewManagerRootConnection(
 311         make_scoped_ptr(root), connection_manager_.get());
 312     root->Init(root_connection_);
 313     wm_client_ = delegate_.last_client();
 314   }
 315
 316  private:
 317   // TestViewManagerClient that is used for the WM connection.
 318   TestViewManagerClient* wm_client_;
 319   TestDisplayManagerFactory display_manager_factory_;
 320   TestConnectionManagerDelegate delegate_;
 321   TestViewManagerRootConnection* root_connection_;
 322   scoped_ptr<ConnectionManager> connection_manager_;
 323   base::MessageLoop message_loop_;
 324
 325   DISALLOW_COPY_AND_ASSIGN(ViewManagerServiceTest);
 326 };
 327
 328 namespace {
 329
 330 const ServerView* GetFirstCloned(const ServerView* view) {
 331   for (const ServerView* child : view->GetChildren()) {
 332     if (child->id() == ClonedViewId())
 333       return child;
 334   }
 335   return nullptr;
 336 }
 337
 338 // Provides common setup for animation tests. Creates the following views:
 339 // 0,1 (the root, provided by view manager)
 340 //   1,1 the second connection is embedded here (view owned by wm_connection()).
 341 //     2,1 bounds=1,2 11x22
 342 //       2,2 bounds=2,3 6x7
 343 //         2,3 bounds=3,4 6x7
 344 // CloneAndAnimate() is invoked for 2,2.
 345 void SetUpAnimate1(ViewManagerServiceTest* test, ViewId* embed_view_id) {
 346   *embed_view_id = ViewId(test->wm_connection()->id(), 1);
 347   EXPECT_EQ(ERROR_CODE_NONE, test->wm_connection()->CreateView(*embed_view_id));
 348   EXPECT_TRUE(test->wm_connection()->SetViewVisibility(*embed_view_id, true));
 349   EXPECT_TRUE(test->wm_connection()->AddView(*(test->wm_connection()->root()),
 350                                              *embed_view_id));
 351   mojo::URLRequestPtr request(mojo::URLRequest::New());
 352   test->wm_connection()->EmbedAllowingReembed(*embed_view_id, request.Pass(),
 353                                               mojo::Callback<void(bool)>());
 354   ViewManagerServiceImpl* connection1 =
 355       test->connection_manager()->GetConnectionWithRoot(*embed_view_id);
 356   ASSERT_TRUE(connection1 != nullptr);
 357   ASSERT_NE(connection1, test->wm_connection());
 358
 359   const ViewId child1(connection1->id(), 1);
 360   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child1));
 361   const ViewId child2(connection1->id(), 2);
 362   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child2));
 363   const ViewId child3(connection1->id(), 3);
 364   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child3));
 365
 366   ServerView* v1 = connection1->GetView(child1);
 367   v1->SetVisible(true);
 368   v1->SetBounds(gfx::Rect(1, 2, 11, 22));
 369   ServerView* v2 = connection1->GetView(child2);
 370   v2->SetVisible(true);
 371   v2->SetBounds(gfx::Rect(2, 3, 6, 7));
 372   ServerView* v3 = connection1->GetView(child3);
 373   v3->SetVisible(true);
 374   v3->SetBounds(gfx::Rect(3, 4, 6, 7));
 375
 376   EXPECT_TRUE(connection1->AddView(*embed_view_id, child1));
 377   EXPECT_TRUE(connection1->AddView(child1, child2));
 378   EXPECT_TRUE(connection1->AddView(child2, child3));
 379
 380   TestViewManagerClient* connection1_client = test->last_view_manager_client();
 381   connection1_client->tracker()->changes()->clear();
 382   test->wm_client()->tracker()->changes()->clear();
 383   EXPECT_TRUE(test->connection_manager()->CloneAndAnimate(child2));
 384   EXPECT_TRUE(connection1_client->tracker()->changes()->empty());
 385   EXPECT_TRUE(test->wm_client()->tracker()->changes()->empty());
 386
 387   // We cloned v2. The cloned view ends up as a sibling of it.
 388   const ServerView* cloned_view = GetFirstCloned(connection1->GetView(child1));
 389   ASSERT_TRUE(cloned_view);
 390   // |cloned_view| should have one and only one cloned child (corresponds to
 391   // |child3|).
 392   ASSERT_EQ(1u, cloned_view->GetChildren().size());
 393   EXPECT_TRUE(cloned_view->GetChildren()[0]->id() == ClonedViewId());
 394
 395   // Cloned views should match the bounds of the view they were cloned from.
 396   EXPECT_EQ(v2->bounds(), cloned_view->bounds());
 397   EXPECT_EQ(v3->bounds(), cloned_view->GetChildren()[0]->bounds());
 398
 399   // Cloned views are owned by the ConnectionManager and shouldn't be returned
 400   // from ViewManagerServiceImpl::GetView.
 401   EXPECT_TRUE(connection1->GetView(ClonedViewId()) == nullptr);
 402   EXPECT_TRUE(test->wm_connection()->GetView(ClonedViewId()) == nullptr);
 403 }
 404
 405 }  // namespace
 406
 407 // Verifies ViewManagerService::GetViewTree() doesn't return cloned views.
 408 TEST_F(ViewManagerServiceTest, ConnectionsCantSeeClonedViews) {
 409   ViewId embed_view_id;
 410   EXPECT_NO_FATAL_FAILURE(SetUpAnimate1(this, &embed_view_id));
 411
 412   ViewManagerServiceImpl* connection1 =
 413       connection_manager()->GetConnectionWithRoot(embed_view_id);
 414
 415   const ViewId child1(connection1->id(), 1);
 416   const ViewId child2(connection1->id(), 2);
 417   const ViewId child3(connection1->id(), 3);
 418
 419   // Verify the root doesn't see any cloned views.
 420   std::vector<const ServerView*> views(
 421       wm_connection()->GetViewTree(*wm_connection()->root()));
 422   ASSERT_EQ(5u, views.size());
 423   ASSERT_TRUE(views[0]->id() == *wm_connection()->root());
 424   ASSERT_TRUE(views[1]->id() == embed_view_id);
 425   ASSERT_TRUE(views[2]->id() == child1);
 426   ASSERT_TRUE(views[3]->id() == child2);
 427   ASSERT_TRUE(views[4]->id() == child3);
 428
 429   // Verify connection1 doesn't see any cloned views.
 430   std::vector<const ServerView*> v1_views(
 431       connection1->GetViewTree(embed_view_id));
 432   ASSERT_EQ(4u, v1_views.size());
 433   ASSERT_TRUE(v1_views[0]->id() == embed_view_id);
 434   ASSERT_TRUE(v1_views[1]->id() == child1);
 435   ASSERT_TRUE(v1_views[2]->id() == child2);
 436   ASSERT_TRUE(v1_views[3]->id() == child3);
 437 }
 438
 439 TEST_F(ViewManagerServiceTest, ClonedViewsPromotedOnConnectionClose) {
 440   ViewId embed_view_id;
 441   EXPECT_NO_FATAL_FAILURE(SetUpAnimate1(this, &embed_view_id));
 442
 443   // Destroy connection1, which should force the cloned view to become a child
 444   // of where it was embedded (the embedded view still exists).
 445   connection_manager()->OnConnectionError(last_client_connection());
 446
 447   ServerView* embed_view = wm_connection()->GetView(embed_view_id);
 448   ASSERT_TRUE(embed_view != nullptr);
 449   const ServerView* cloned_view = GetFirstCloned(embed_view);
 450   ASSERT_TRUE(cloned_view);
 451   ASSERT_EQ(1u, cloned_view->GetChildren().size());
 452   EXPECT_TRUE(cloned_view->GetChildren()[0]->id() == ClonedViewId());
 453
 454   // Because the cloned view changed parents its bounds should have changed.
 455   EXPECT_EQ(gfx::Rect(3, 5, 6, 7), cloned_view->bounds());
 456   // The bounds of the cloned child should not have changed though.
 457   EXPECT_EQ(gfx::Rect(3, 4, 6, 7), cloned_view->GetChildren()[0]->bounds());
 458 }
 459
 460 TEST_F(ViewManagerServiceTest, ClonedViewsPromotedOnHide) {
 461   ViewId embed_view_id;
 462   EXPECT_NO_FATAL_FAILURE(SetUpAnimate1(this, &embed_view_id));
 463
 464   ViewManagerServiceImpl* connection1 =
 465       connection_manager()->GetConnectionWithRoot(embed_view_id);
 466
 467   // Hide the parent of the cloned view, which should force the cloned view to
 468   // become a sibling of the parent.
 469   const ServerView* view_to_hide =
 470       connection1->GetView(ViewId(connection1->id(), 1));
 471   ASSERT_TRUE(connection1->SetViewVisibility(view_to_hide->id(), false));
 472
 473   const ServerView* cloned_view = GetFirstCloned(view_to_hide->parent());
 474   ASSERT_TRUE(cloned_view);
 475   ASSERT_EQ(1u, cloned_view->GetChildren().size());
 476   EXPECT_TRUE(cloned_view->GetChildren()[0]->id() == ClonedViewId());
 477   EXPECT_EQ(2u, cloned_view->parent()->GetChildren().size());
 478   EXPECT_TRUE(cloned_view->parent()->GetChildren()[1] == cloned_view);
 479 }
 480
 481 // Clone and animate on a tree with more depth. Basically that of
 482 // SetUpAnimate1() but cloning 2,1.
 483 TEST_F(ViewManagerServiceTest, CloneAndAnimateLargerDepth) {
 484   const ViewId embed_view_id(wm_connection()->id(), 1);
 485   EXPECT_EQ(ERROR_CODE_NONE, wm_connection()->CreateView(embed_view_id));
 486   EXPECT_TRUE(wm_connection()->SetViewVisibility(embed_view_id, true));
 487   EXPECT_TRUE(
 488       wm_connection()->AddView(*(wm_connection()->root()), embed_view_id));
 489   mojo::URLRequestPtr request(mojo::URLRequest::New());
 490   wm_connection()->EmbedAllowingReembed(embed_view_id, request.Pass(),
 491                                         mojo::Callback<void(bool)>());
 492   ViewManagerServiceImpl* connection1 =
 493       connection_manager()->GetConnectionWithRoot(embed_view_id);
 494   ASSERT_TRUE(connection1 != nullptr);
 495   ASSERT_NE(connection1, wm_connection());
 496
 497   const ViewId child1(connection1->id(), 1);
 498   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child1));
 499   const ViewId child2(connection1->id(), 2);
 500   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child2));
 501   const ViewId child3(connection1->id(), 3);
 502   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child3));
 503
 504   ServerView* v1 = connection1->GetView(child1);
 505   v1->SetVisible(true);
 506   connection1->GetView(child2)->SetVisible(true);
 507   connection1->GetView(child3)->SetVisible(true);
 508
 509   EXPECT_TRUE(connection1->AddView(embed_view_id, child1));
 510   EXPECT_TRUE(connection1->AddView(child1, child2));
 511   EXPECT_TRUE(connection1->AddView(child2, child3));
 512
 513   TestViewManagerClient* connection1_client = last_view_manager_client();
 514   connection1_client->tracker()->changes()->clear();
 515   wm_client()->tracker()->changes()->clear();
 516   EXPECT_TRUE(connection_manager()->CloneAndAnimate(child1));
 517   EXPECT_TRUE(connection1_client->tracker()->changes()->empty());
 518   EXPECT_TRUE(wm_client()->tracker()->changes()->empty());
 519
 520   // We cloned v1. The cloned view ends up as a sibling of it.
 521   const ServerView* cloned_view = GetFirstCloned(v1->parent());
 522   ASSERT_TRUE(cloned_view);
 523   // |cloned_view| should have a child and its child should have a child.
 524   ASSERT_EQ(1u, cloned_view->GetChildren().size());
 525   const ServerView* cloned_view_child = cloned_view->GetChildren()[0];
 526   EXPECT_EQ(1u, cloned_view_child->GetChildren().size());
 527   EXPECT_TRUE(cloned_view_child->id() == ClonedViewId());
 528 }
 529
 530 // Verifies focus correctly changes on pointer events.
 531 TEST_F(ViewManagerServiceTest, FocusOnPointer) {
 532   const ViewId embed_view_id(wm_connection()->id(), 1);
 533   EXPECT_EQ(ERROR_CODE_NONE, wm_connection()->CreateView(embed_view_id));
 534   EXPECT_TRUE(wm_connection()->SetViewVisibility(embed_view_id, true));
 535   EXPECT_TRUE(
 536       wm_connection()->AddView(*(wm_connection()->root()), embed_view_id));
 537   root_connection()->view_manager_root()->root_view()->
 538       SetBounds(gfx::Rect(0, 0, 100, 100));
 539   mojo::URLRequestPtr request(mojo::URLRequest::New());
 540   wm_connection()->EmbedAllowingReembed(embed_view_id, request.Pass(),
 541                                         mojo::Callback<void(bool)>());
 542   ViewManagerServiceImpl* connection1 =
 543       connection_manager()->GetConnectionWithRoot(embed_view_id);
 544   ASSERT_TRUE(connection1 != nullptr);
 545   ASSERT_NE(connection1, wm_connection());
 546
 547   connection_manager()
 548       ->GetView(embed_view_id)
 549       ->SetBounds(gfx::Rect(0, 0, 50, 50));
 550
 551   const ViewId child1(connection1->id(), 1);
 552   EXPECT_EQ(ERROR_CODE_NONE, connection1->CreateView(child1));
 553   EXPECT_TRUE(connection1->AddView(embed_view_id, child1));
 554   ServerView* v1 = connection1->GetView(child1);
 555   v1->SetVisible(true);
 556   v1->SetBounds(gfx::Rect(20, 20, 20, 20));
 557
 558   TestViewManagerClient* connection1_client = last_view_manager_client();
 559   connection1_client->tracker()->changes()->clear();
 560   wm_client()->tracker()->changes()->clear();
 561
 562   connection_manager()->OnEvent(root_connection()->view_manager_root(),
 563                                 CreatePointerDownEvent(21, 22));
 564   // Focus should go to child1. This results in notifying both the window
 565   // manager and client connection being notified.
 566   EXPECT_EQ(v1, connection_manager()->GetFocusedView());
 567   ASSERT_GE(wm_client()->tracker()->changes()->size(), 1u);
 568   EXPECT_EQ("Focused id=2,1",
 569             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
 570   ASSERT_GE(connection1_client->tracker()->changes()->size(), 1u);
 571   EXPECT_EQ(
 572       "Focused id=2,1",
 573       ChangesToDescription1(*connection1_client->tracker()->changes())[0]);
 574
 575   connection_manager()->OnEvent(root_connection()->view_manager_root(),
 576                                 CreatePointerUpEvent(21, 22));
 577   wm_client()->tracker()->changes()->clear();
 578   connection1_client->tracker()->changes()->clear();
 579
 580   // Press outside of the embedded view. Focus should go to the root. Notice
 581   // the client1 doesn't see who has focus as the focused view (root) isn't
 582   // visible to it.
 583   connection_manager()->OnEvent(root_connection()->view_manager_root(),
 584                                 CreatePointerDownEvent(61, 22));
 585   EXPECT_EQ(root_connection()->view_manager_root()->root_view(),
 586             connection_manager()->GetFocusedView());
 587   ASSERT_GE(wm_client()->tracker()->changes()->size(), 1u);
 588   EXPECT_EQ("Focused id=0,2",
 589             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
 590   ASSERT_GE(connection1_client->tracker()->changes()->size(), 1u);
 591   EXPECT_EQ(
 592       "Focused id=null",
 593       ChangesToDescription1(*connection1_client->tracker()->changes())[0]);
 594
 595   connection_manager()->OnEvent(root_connection()->view_manager_root(),
 596                                 CreatePointerUpEvent(21, 22));
 597   wm_client()->tracker()->changes()->clear();
 598   connection1_client->tracker()->changes()->clear();
 599
 600   // Press in the same location. Should not get a focus change event (only input
 601   // event).
 602   connection_manager()->OnEvent(root_connection()->view_manager_root(),
 603                                 CreatePointerDownEvent(61, 22));
 604   EXPECT_EQ(root_connection()->view_manager_root()->root_view(),
 605             connection_manager()->GetFocusedView());
 606   ASSERT_EQ(wm_client()->tracker()->changes()->size(), 1u);
 607   EXPECT_EQ("InputEvent view=0,2 event_action=4",
 608             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
 609   EXPECT_TRUE(connection1_client->tracker()->changes()->empty());
 610 }
 611
 612 }  // namespace view_manager