mojo/services/view_manager/view_manager_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 <string>
#include <vector>

#include "base/at_exit.h"
#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "mojo/application_manager/application_manager.h"
#include "mojo/common/common_type_converters.h"
#include "mojo/public/cpp/application/application_connection.h"
#include "mojo/public/cpp/application/application_delegate.h"
#include "mojo/public/cpp/application/application_impl.h"
#include "mojo/public/cpp/application/connect.h"
#include "mojo/public/cpp/bindings/lib/router.h"
#include "mojo/public/interfaces/application/service_provider.mojom.h"
#include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
#include "mojo/services/public/cpp/view_manager/types.h"
#include "mojo/services/public/cpp/view_manager/util.h"
#include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
#include "mojo/services/view_manager/ids.h"
#include "mojo/services/view_manager/test_change_tracker.h"
#include "mojo/shell/shell_test_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/geometry/rect.h"

namespace mojo {
namespace service {

namespace {

const char kTestServiceURL[] = "mojo:test_url";
const char kTestServiceURL2[] = "mojo:test_url2";

// ViewManagerProxy is a proxy to an ViewManagerService. It handles invoking
// ViewManagerService functions on the right thread in a synchronous manner
// (each ViewManagerService cover function blocks until the response from the
// ViewManagerService is returned). In addition it tracks the set of
// ViewManagerClient messages received by way of a vector of Changes. Use
// DoRunLoopUntilChangesCount() to wait for a certain number of messages to be
// received.
class ViewManagerProxy : public TestChangeTracker::Delegate {
 public:
  explicit ViewManagerProxy(TestChangeTracker* tracker)
      : tracker_(tracker),
        main_loop_(NULL),
        view_manager_(NULL),
        quit_count_(0),
        router_(NULL) {
    SetInstance(this);
  }

  virtual ~ViewManagerProxy() {
  }

  // Runs a message loop until the single instance has been created.
  static ViewManagerProxy* WaitForInstance() {
    if (!instance_)
      RunMainLoop();
    ViewManagerProxy* instance = instance_;
    instance_ = NULL;
    return instance;
  }

  ViewManagerService* view_manager() { return view_manager_; }

  // Runs the main loop until |count| changes have been received.
  std::vector<Change> DoRunLoopUntilChangesCount(size_t count) {
    DCHECK_EQ(0u, quit_count_);
    if (tracker_->changes()->size() >= count) {
      CopyChangesFromTracker();
      return changes_;
    }
    quit_count_ = count - tracker_->changes()->size();
    // Run the current message loop. When |count| Changes have been received,
    // we'll quit.
    RunMainLoop();
    return changes_;
  }

  const std::vector<Change>& changes() const { return changes_; }

  // Destroys the connection, blocking until done.
  void Destroy() {
    router_->CloseMessagePipe();
  }

  void ClearChanges() {
    changes_.clear();
    tracker_->changes()->clear();
  }

  void CopyChangesFromTracker() {
    std::vector<Change> changes;
    tracker_->changes()->swap(changes);
    changes_.swap(changes);
  }

  // The following functions are cover methods for ViewManagerService. They
  // block until the result is received.
  bool CreateNode(Id node_id) {
    changes_.clear();
    ErrorCode result = ERROR_CODE_NONE;
    view_manager_->CreateView(
        node_id,
        base::Bind(&ViewManagerProxy::GotResultWithErrorCode,
                   base::Unretained(this), &result));
    RunMainLoop();
    return result == ERROR_CODE_NONE;
  }
  ErrorCode CreateNodeWithErrorCode(Id node_id) {
    changes_.clear();
    ErrorCode result = ERROR_CODE_NONE;
    view_manager_->CreateView(
        node_id,
        base::Bind(&ViewManagerProxy::GotResultWithErrorCode,
                   base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  bool AddNode(Id parent, Id child) {
    changes_.clear();
    bool result = false;
    view_manager_->AddView(parent, child,
                           base::Bind(&ViewManagerProxy::GotResult,
                                      base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  bool RemoveNodeFromParent(Id node_id) {
    changes_.clear();
    bool result = false;
    view_manager_->RemoveViewFromParent(node_id,
        base::Bind(&ViewManagerProxy::GotResult,
                   base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  bool ReorderNode(Id node_id,
                   Id relative_node_id,
                   OrderDirection direction) {
    changes_.clear();
    bool result = false;
    view_manager_->ReorderView(node_id, relative_node_id, direction,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  void GetNodeTree(Id node_id, std::vector<TestNode>* nodes) {
    changes_.clear();
    view_manager_->GetViewTree(node_id,
                               base::Bind(&ViewManagerProxy::GotNodeTree,
                                          base::Unretained(this), nodes));
    RunMainLoop();
  }
  bool Embed(const Id node_id, const char* url) {
    changes_.clear();
    base::AutoReset<bool> auto_reset(&in_embed_, true);
    bool result = false;
    ServiceProviderPtr services;
    view_manager_->Embed(url, node_id, services.Pass(),
                         base::Bind(&ViewManagerProxy::GotResult,
                                    base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  bool DeleteNode(Id node_id) {
    changes_.clear();
    bool result = false;
    view_manager_->DeleteView(node_id,
                              base::Bind(&ViewManagerProxy::GotResult,
                                         base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }
  bool SetNodeBounds(Id node_id, const gfx::Rect& bounds) {
    changes_.clear();
    bool result = false;
    view_manager_->SetViewBounds(node_id, Rect::From(bounds),
                                 base::Bind(&ViewManagerProxy::GotResult,
                                            base::Unretained(this), &result));
    RunMainLoop();
    return result;
  }

 private:
  friend class TestViewManagerClientConnection;

  void set_router(mojo::internal::Router* router) { router_ = router; }

  void set_view_manager(ViewManagerService* view_manager) {
    view_manager_ = view_manager;
  }

  static void RunMainLoop() {
    DCHECK(!main_run_loop_);
    main_run_loop_ = new base::RunLoop;
    main_run_loop_->Run();
    delete main_run_loop_;
    main_run_loop_ = NULL;
  }

  void QuitCountReached() {
    CopyChangesFromTracker();
    main_run_loop_->Quit();
  }

  static void SetInstance(ViewManagerProxy* instance) {
    DCHECK(!instance_);
    instance_ = instance;
    // Embed() runs its own run loop that is quit when the result is
    // received. Embed() also results in a new instance. If we quit here while
    // waiting for a Embed() we would prematurely return before we got the
    // result from Embed().
    if (!in_embed_ && main_run_loop_)
      main_run_loop_->Quit();
  }

  // Callbacks from the various ViewManagerService functions.
  void GotResult(bool* result_cache, bool result) {
    *result_cache = result;
    DCHECK(main_run_loop_);
    main_run_loop_->Quit();
  }

  void GotResultWithErrorCode(ErrorCode* error_code_cache,
                              ErrorCode error_code) {
    *error_code_cache = error_code;
    DCHECK(main_run_loop_);
    main_run_loop_->Quit();
  }

  void GotNodeTree(std::vector<TestNode>* nodes, Array<ViewDataPtr> results) {
    ViewDatasToTestNodes(results, nodes);
    DCHECK(main_run_loop_);
    main_run_loop_->Quit();
  }

  // TestChangeTracker::Delegate:
  virtual void OnChangeAdded() OVERRIDE {
    if (quit_count_ > 0 && --quit_count_ == 0)
      QuitCountReached();
  }

  static ViewManagerProxy* instance_;
  static base::RunLoop* main_run_loop_;
  static bool in_embed_;

  TestChangeTracker* tracker_;

  // MessageLoop of the test.
  base::MessageLoop* main_loop_;

  ViewManagerService* view_manager_;

  // Number of changes we're waiting on until we quit the current loop.
  size_t quit_count_;

  std::vector<Change> changes_;

  mojo::internal::Router* router_;

  DISALLOW_COPY_AND_ASSIGN(ViewManagerProxy);
};

// static
ViewManagerProxy* ViewManagerProxy::instance_ = NULL;

// static
base::RunLoop* ViewManagerProxy::main_run_loop_ = NULL;

// static
bool ViewManagerProxy::in_embed_ = false;

class TestViewManagerClientConnection
    : public InterfaceImpl<ViewManagerClient> {
 public:
  TestViewManagerClientConnection() : connection_(&tracker_) {
    tracker_.set_delegate(&connection_);
  }

  // InterfaceImpl:
  virtual void OnConnectionEstablished() OVERRIDE {
    connection_.set_router(internal_state()->router());
    connection_.set_view_manager(client());
  }

  // ViewManagerClient:
  virtual void OnEmbed(
      ConnectionSpecificId connection_id,
      const String& creator_url,
      ViewDataPtr root,
      InterfaceRequest<ServiceProvider> services) OVERRIDE {
    tracker_.OnEmbed(connection_id, creator_url, root.Pass());
  }
  virtual void OnViewBoundsChanged(Id node_id,
                                   RectPtr old_bounds,
                                   RectPtr new_bounds) OVERRIDE {
    tracker_.OnNodeBoundsChanged(node_id, old_bounds.Pass(), new_bounds.Pass());
  }
  virtual void OnViewHierarchyChanged(Id node,
                                      Id new_parent,
                                      Id old_parent,
                                      Array<ViewDataPtr> nodes) OVERRIDE {
    tracker_.OnNodeHierarchyChanged(node, new_parent, old_parent, nodes.Pass());
  }
  virtual void OnViewReordered(Id node_id,
                               Id relative_node_id,
                               OrderDirection direction) OVERRIDE {
    tracker_.OnNodeReordered(node_id, relative_node_id, direction);
  }
  virtual void OnViewDeleted(Id node) OVERRIDE {
    tracker_.OnNodeDeleted(node);
  }
  virtual void OnViewInputEvent(Id node_id,
                                EventPtr event,
                                const Callback<void()>& callback) OVERRIDE {
    tracker_.OnNodeInputEvent(node_id, event.Pass());
  }
  virtual void Embed(
      const String& url,
      InterfaceRequest<ServiceProvider> service_provider) OVERRIDE {
    tracker_.DelegateEmbed(url);
  }
  virtual void DispatchOnViewInputEvent(mojo::EventPtr event) OVERRIDE {
  }

 private:
  TestChangeTracker tracker_;
  ViewManagerProxy connection_;

  DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
};

// Used with ViewManagerService::Embed(). Creates a
// TestViewManagerClientConnection, which creates and owns the ViewManagerProxy.
class EmbedApplicationLoader : public ApplicationLoader,
                               ApplicationDelegate,
                               public InterfaceFactory<ViewManagerClient> {
 public:
  EmbedApplicationLoader() {}
  virtual ~EmbedApplicationLoader() {}

  // ApplicationLoader implementation:
  virtual void Load(ApplicationManager* manager,
                    const GURL& url,
                    scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
    ScopedMessagePipeHandle shell_handle = callbacks->RegisterApplication();
    if (!shell_handle.is_valid())
      return;
    scoped_ptr<ApplicationImpl> app(new ApplicationImpl(this,
                                                        shell_handle.Pass()));
    apps_.push_back(app.release());
  }
  virtual void OnServiceError(ApplicationManager* manager,
                              const GURL& url) OVERRIDE {}

  // ApplicationDelegate implementation:
  virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
      OVERRIDE {
    connection->AddService(this);
    return true;
  }

  // InterfaceFactory<ViewManagerClient> implementation:
  virtual void Create(ApplicationConnection* connection,
                      InterfaceRequest<ViewManagerClient> request) OVERRIDE {
    BindToRequest(new TestViewManagerClientConnection, &request);
  }

 private:
  ScopedVector<ApplicationImpl> apps_;

  DISALLOW_COPY_AND_ASSIGN(EmbedApplicationLoader);
};

// Creates an id used for transport from the specified parameters.
Id BuildNodeId(ConnectionSpecificId connection_id,
               ConnectionSpecificId node_id) {
  return (connection_id << 16) | node_id;
}

// Callback from Embed(). |result| is the result of the
// Embed() call and |run_loop| the nested RunLoop.
void EmbedCallback(bool* result_cache, base::RunLoop* run_loop, bool result) {
  *result_cache = result;
  run_loop->Quit();
}

// Embed from an application that does not yet have a view manager connection.
// Blocks until result is determined.
bool InitEmbed(ViewManagerInitService* view_manager_init,
               const std::string& url,
               size_t number_of_calls) {
  bool result = false;
  base::RunLoop run_loop;
  for (size_t i = 0; i < number_of_calls; ++i) {
    ServiceProviderPtr sp;
    view_manager_init->Embed(url, sp.Pass(),
                             base::Bind(&EmbedCallback, &result, &run_loop));
  }
  run_loop.Run();
  return result;
}

}  // namespace

typedef std::vector<std::string> Changes;

class ViewManagerTest : public testing::Test {
 public:
  ViewManagerTest()
      : connection_(NULL),
        connection2_(NULL),
        connection3_(NULL) {}

  virtual void SetUp() OVERRIDE {
    test_helper_.Init();

    test_helper_.SetLoaderForURL(
        scoped_ptr<ApplicationLoader>(new EmbedApplicationLoader()),
        GURL(kTestServiceURL));

    test_helper_.SetLoaderForURL(
        scoped_ptr<ApplicationLoader>(new EmbedApplicationLoader()),
        GURL(kTestServiceURL2));

    test_helper_.application_manager()->ConnectToService(
        GURL("mojo:mojo_view_manager"), &view_manager_init_);
    ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 1));

    connection_ = ViewManagerProxy::WaitForInstance();
    ASSERT_TRUE(connection_ != NULL);
    connection_->DoRunLoopUntilChangesCount(1);
  }

  virtual void TearDown() OVERRIDE {
    if (connection3_)
      connection3_->Destroy();
    if (connection2_)
      connection2_->Destroy();
    if (connection_)
      connection_->Destroy();
  }

 protected:
  void EstablishSecondConnectionWithRoot(Id root_id) {
    ASSERT_TRUE(connection_->Embed(root_id, kTestServiceURL));
    connection2_ = ViewManagerProxy::WaitForInstance();
    ASSERT_TRUE(connection2_ != NULL);
    connection2_->DoRunLoopUntilChangesCount(1);
    ASSERT_EQ(1u, connection2_->changes().size());
  }

  // Creates a second connection to the viewmanager.
  void EstablishSecondConnection(bool create_initial_node) {
    if (create_initial_node)
      ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
    ASSERT_NO_FATAL_FAILURE(
        EstablishSecondConnectionWithRoot(BuildNodeId(1, 1)));
    const std::vector<Change>& changes(connection2_->changes());
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("OnEmbed creator=mojo:test_url",
              ChangesToDescription1(changes)[0]);
    if (create_initial_node) {
      EXPECT_EQ("[node=1,1 parent=null]",
                ChangeNodeDescription(changes));
    }
  }

  void EstablishThirdConnection(ViewManagerProxy* owner, Id root_id) {
    ASSERT_TRUE(connection3_ == NULL);
    ASSERT_TRUE(owner->Embed(root_id, kTestServiceURL2));
    connection3_ = ViewManagerProxy::WaitForInstance();
    ASSERT_TRUE(connection3_ != NULL);
    connection3_->DoRunLoopUntilChangesCount(1);
    ASSERT_EQ(1u, connection3_->changes().size());
    EXPECT_EQ("OnEmbed creator=mojo:test_url",
              ChangesToDescription1(connection3_->changes())[0]);
  }

  void DestroySecondConnection() {
    connection2_->Destroy();
    connection2_ = NULL;
  }

  base::ShadowingAtExitManager at_exit_;
  shell::ShellTestHelper test_helper_;

  ViewManagerInitServicePtr view_manager_init_;

  // NOTE: this connection is the root. As such, it has special permissions.
  ViewManagerProxy* connection_;
  ViewManagerProxy* connection2_;
  ViewManagerProxy* connection3_;

  DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
};

TEST_F(ViewManagerTest, SecondEmbedRoot_InitService) {
  ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 1));
  connection_->DoRunLoopUntilChangesCount(1);
  EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
}

TEST_F(ViewManagerTest, SecondEmbedRoot_Service) {
  ASSERT_TRUE(connection_->Embed(BuildNodeId(0, 0), kTestServiceURL));
  connection_->DoRunLoopUntilChangesCount(1);
  EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
}

TEST_F(ViewManagerTest, MultipleEmbedRootsBeforeWTHReady) {
  ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 2));
  connection_->DoRunLoopUntilChangesCount(2);
  EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
  EXPECT_EQ(kTestServiceURL, connection_->changes()[1].embed_url);
}

// Verifies client gets a valid id.
#if defined(OS_LINUX)
// http://crbug.com/396492
#define MAYBE_ValidId DISABLED_ValidId
#else
#define MAYBE_ValidId ValidId
#endif
TEST_F(ViewManagerTest, MAYBE_ValidId) {
  // TODO(beng): this should really have the URL of the application that
  //             connected to ViewManagerInit.
  EXPECT_EQ("OnEmbed creator=",
            ChangesToDescription1(connection_->changes())[0]);

  // All these tests assume 1 for the client id. The only real assertion here is
  // the client id is not zero, but adding this as rest of code here assumes 1.
  EXPECT_EQ(1, connection_->changes()[0].connection_id);
}

// Verifies two clients/connections get different ids.
TEST_F(ViewManagerTest, TwoClientsGetDifferentConnectionIds) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
  EXPECT_EQ("OnEmbed creator=mojo:test_url",
            ChangesToDescription1(connection2_->changes())[0]);

  // It isn't strictly necessary that the second connection gets 2, but these
  // tests are written assuming that is the case. The key thing is the
  // connection ids of |connection_| and |connection2_| differ.
  EXPECT_EQ(2, connection2_->changes()[0].connection_id);
}

// Verifies when Embed() is invoked any child nodes are removed.
TEST_F(ViewManagerTest, NodesRemovedWhenEmbedding) {
  // Two nodes 1 and 2. 2 is parented to 1.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
  EXPECT_EQ("[node=1,1 parent=null]",
            ChangeNodeDescription(connection2_->changes()));

  // Embed() removed node 2.
  {
    std::vector<TestNode> nodes;
    connection_->GetNodeTree(BuildNodeId(1, 2), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=1,2 parent=null", nodes[0].ToString());
  }

  // |connection2_| should not see node 2.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=1,1 parent=null", nodes[0].ToString());
  }
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(1, 2), &nodes);
    EXPECT_TRUE(nodes.empty());
  }

  // Nodes 3 and 4 in connection 2.
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 3)));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 4)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(2, 3), BuildNodeId(2, 4)));

  // Connection 3 rooted at 2.
  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(connection2_,
                                                   BuildNodeId(2, 3)));

  // Node 4 should no longer have a parent.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(2, 3), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=2,3 parent=null", nodes[0].ToString());

    nodes.clear();
    connection2_->GetNodeTree(BuildNodeId(2, 4), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=2,4 parent=null", nodes[0].ToString());
  }

  // And node 4 should not be visible to connection 3.
  {
    std::vector<TestNode> nodes;
    connection3_->GetNodeTree(BuildNodeId(2, 3), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=2,3 parent=null", nodes[0].ToString());
  }
}

// Verifies once Embed() has been invoked the parent connection can't see any
// children.
TEST_F(ViewManagerTest, CantAccessChildrenOfEmbeddedNode) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(connection2_,
                                                   BuildNodeId(2, 2)));

  ASSERT_TRUE(connection3_->CreateNode(BuildNodeId(3, 3)));
  ASSERT_TRUE(connection3_->AddNode(BuildNodeId(2, 2), BuildNodeId(3, 3)));

  // Even though 3 is a child of 2 connection 2 can't see 3 as it's from a
  // different connection.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(2, 2), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=2,2 parent=1,1", nodes[0].ToString());
  }

  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(3, 3), &nodes);
    EXPECT_TRUE(nodes.empty());
  }

  // Connection 2 shouldn't be able to get node 3 at all.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(3, 3), &nodes);
    EXPECT_TRUE(nodes.empty());
  }

  // Connection 1 should be able to see it all (its the root).
  {
    std::vector<TestNode> nodes;
    connection_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    ASSERT_EQ(3u, nodes.size());
    EXPECT_EQ("node=1,1 parent=null", nodes[0].ToString());
    EXPECT_EQ("node=2,2 parent=1,1", nodes[1].ToString());
    EXPECT_EQ("node=3,3 parent=2,2", nodes[2].ToString());
  }
}

// Verifies once Embed() has been invoked the parent can't mutate the children.
TEST_F(ViewManagerTest, CantModifyChildrenOfEmbeddedNode) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(connection2_,
                                                   BuildNodeId(2, 2)));

  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 3)));
  // Connection 2 shouldn't be able to add anything to the node anymore.
  ASSERT_FALSE(connection2_->AddNode(BuildNodeId(2, 2), BuildNodeId(2, 3)));

  // Create node 3 in connection 3 and add it to node 3.
  ASSERT_TRUE(connection3_->CreateNode(BuildNodeId(3, 3)));
  ASSERT_TRUE(connection3_->AddNode(BuildNodeId(2, 2), BuildNodeId(3, 3)));

  // Connection 2 shouldn't be able to remove node 3.
  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(3, 3)));
}

// Verifies client gets a valid id.
TEST_F(ViewManagerTest, CreateNode) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  EXPECT_TRUE(connection_->changes().empty());

  // Can't create a node with the same id.
  ASSERT_EQ(ERROR_CODE_VALUE_IN_USE,
            connection_->CreateNodeWithErrorCode(BuildNodeId(1, 1)));
  EXPECT_TRUE(connection_->changes().empty());

  // Can't create a node with a bogus connection id.
  EXPECT_EQ(ERROR_CODE_ILLEGAL_ARGUMENT,
            connection_->CreateNodeWithErrorCode(BuildNodeId(2, 1)));
  EXPECT_TRUE(connection_->changes().empty());
}

// Verifies AddNode fails when node is already in position.
TEST_F(ViewManagerTest, AddNodeWithNoChange) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  // Make 3 a child of 2.
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3)));

  // Try again, this should fail.
  EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3)));
}

// Verifies AddNode fails when node is already in position.
TEST_F(ViewManagerTest, AddAncestorFails) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  // Make 3 a child of 2.
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3)));

  // Try to make 2 a child of 3, this should fail since 2 is an ancestor of 3.
  EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 3), BuildNodeId(1, 2)));
}

// Verifies adding to root sends right notifications.
TEST_F(ViewManagerTest, AddToRoot) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 21)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  // Make 3 a child of 21.
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 21), BuildNodeId(1, 3)));

  // Make 21 a child of 1.
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 21)));

  // Connection 2 should not be told anything (because the node is from a
  // different connection). Create a node to ensure we got a response from
  // the server.
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 100)));
  connection2_->CopyChangesFromTracker();
  EXPECT_TRUE(connection2_->changes().empty());
}

// Verifies HierarchyChanged is correctly sent for various adds/removes.
TEST_F(ViewManagerTest, NodeHierarchyChangedNodes) {
  // 1,2->1,11.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 11)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 11)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  // 1,1->1,2->1,11
  {
    // Client 2 should not get anything (1,2 is from another connection).
    connection2_->ClearChanges();
    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2)));
    ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 100)));
    connection2_->CopyChangesFromTracker();
    EXPECT_TRUE(connection2_->changes().empty());
  }

  // 0,1->1,1->1,2->1,11.
  {
    // Again, client 2 should not get anything.
    connection2_->ClearChanges();
    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
    ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 101)));
    connection2_->CopyChangesFromTracker();
    EXPECT_TRUE(connection2_->changes().empty());
  }

  // 1,1->1,2->1,11.
  {
    connection2_->ClearChanges();
    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 1)));
    EXPECT_TRUE(connection_->changes().empty());
    ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 102)));
    connection2_->CopyChangesFromTracker();
    EXPECT_TRUE(connection2_->changes().empty());
  }

  // 1,1->1,2->1,11->1,111.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 111)));
  {
    connection2_->ClearChanges();
    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 11), BuildNodeId(1, 111)));
    ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 103)));
    connection2_->CopyChangesFromTracker();
    EXPECT_TRUE(connection2_->changes().empty());
  }

  // 0,1->1,1->1,2->1,11->1,111
  {
    connection2_->ClearChanges();
    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
    ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 104)));
    connection2_->CopyChangesFromTracker();
    EXPECT_TRUE(connection2_->changes().empty());
  }
}

TEST_F(ViewManagerTest, NodeHierarchyChangedAddingKnownToUnknown) {
  // Create the following structure: root -> 1 -> 11 and 2->21 (2 has no
  // parent).
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 11)));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 21)));

  // Set up the hierarchy.
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 11)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(2, 2), BuildNodeId(2, 21)));

  // Remove 11, should result in a hierarchy change for the root.
  {
    connection_->ClearChanges();
    ASSERT_TRUE(connection2_->RemoveNodeFromParent(BuildNodeId(2, 11)));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("HierarchyChanged node=2,11 new_parent=null old_parent=1,1",
              changes[0]);
  }

  // Add 2 to 1.
  {
    ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("HierarchyChanged node=2,2 new_parent=1,1 old_parent=null",
              changes[0]);
    EXPECT_EQ("[node=2,2 parent=1,1],"
              "[node=2,21 parent=2,2]",
              ChangeNodeDescription(connection_->changes()));
  }
}

TEST_F(ViewManagerTest, ReorderNode) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  Id node1_id = BuildNodeId(2, 1);
  Id node2_id = BuildNodeId(2, 2);
  Id node3_id = BuildNodeId(2, 3);
  Id node4_id = BuildNodeId(1, 4);  // Peer to 1,1
  Id node5_id = BuildNodeId(1, 5);  // Peer to 1,1
  Id node6_id = BuildNodeId(2, 6);  // Child of 1,2.
  Id node7_id = BuildNodeId(2, 7);  // Unparented.
  Id node8_id = BuildNodeId(2, 8);  // Unparented.
  ASSERT_TRUE(connection2_->CreateNode(node1_id));
  ASSERT_TRUE(connection2_->CreateNode(node2_id));
  ASSERT_TRUE(connection2_->CreateNode(node3_id));
  ASSERT_TRUE(connection_->CreateNode(node4_id));
  ASSERT_TRUE(connection_->CreateNode(node5_id));
  ASSERT_TRUE(connection2_->CreateNode(node6_id));
  ASSERT_TRUE(connection2_->CreateNode(node7_id));
  ASSERT_TRUE(connection2_->CreateNode(node8_id));
  ASSERT_TRUE(connection2_->AddNode(node1_id, node2_id));
  ASSERT_TRUE(connection2_->AddNode(node2_id, node6_id));
  ASSERT_TRUE(connection2_->AddNode(node1_id, node3_id));
  ASSERT_TRUE(connection_->AddNode(
      NodeIdToTransportId(RootNodeId()), node4_id));
  ASSERT_TRUE(connection_->AddNode(
      NodeIdToTransportId(RootNodeId()), node5_id));

  ASSERT_TRUE(connection_->AddNode(
      NodeIdToTransportId(RootNodeId()), node1_id));

  {
    ASSERT_TRUE(
        connection2_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_ABOVE));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("Reordered node=2,2 relative=2,3 direction=above",
              changes[0]);
  }

  {
    ASSERT_TRUE(connection2_->ReorderNode(
                    node2_id, node3_id, ORDER_DIRECTION_BELOW));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("Reordered node=2,2 relative=2,3 direction=below",
              changes[0]);
  }

  // node2 is already below node3.
  EXPECT_FALSE(
      connection2_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_BELOW));

  // node4 & 5 are unknown to connection2_.
  EXPECT_FALSE(connection2_->ReorderNode(
                   node4_id, node5_id, ORDER_DIRECTION_ABOVE));

  // node6 & node3 have different parents.
  EXPECT_FALSE(
      connection_->ReorderNode(node3_id, node6_id, ORDER_DIRECTION_ABOVE));

  // Non-existent node-ids
  EXPECT_FALSE(connection_->ReorderNode(
      BuildNodeId(1, 27), BuildNodeId(1, 28), ORDER_DIRECTION_ABOVE));

  // node7 & node8 are un-parented.
  EXPECT_FALSE(
      connection_->ReorderNode(node7_id, node8_id, ORDER_DIRECTION_ABOVE));
}

// Verifies DeleteNode works.
TEST_F(ViewManagerTest, DeleteNode) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));

  // Make 2 a child of 1.
  {
    ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));
    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("HierarchyChanged node=2,2 new_parent=1,1 old_parent=null",
              changes[0]);
  }

  // Delete 2.
  {
    ASSERT_TRUE(connection2_->DeleteNode(BuildNodeId(2, 2)));
    EXPECT_TRUE(connection2_->changes().empty());

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("NodeDeleted node=2,2", changes[0]);
  }
}

// Verifies DeleteNode isn't allowed from a separate connection.
TEST_F(ViewManagerTest, DeleteNodeFromAnotherConnectionDisallowed) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
  EXPECT_FALSE(connection2_->DeleteNode(BuildNodeId(1, 1)));
}

// Verifies if a node was deleted and then reused that other clients are
// properly notified.
TEST_F(ViewManagerTest, ReuseDeletedNodeId) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));

  // Add 2 to 1.
  {
    ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    EXPECT_EQ("HierarchyChanged node=2,2 new_parent=1,1 old_parent=null",
              changes[0]);
    EXPECT_EQ("[node=2,2 parent=1,1]",
              ChangeNodeDescription(connection_->changes()));
  }

  // Delete 2.
  {
    ASSERT_TRUE(connection2_->DeleteNode(BuildNodeId(2, 2)));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("NodeDeleted node=2,2", changes[0]);
  }

  // Create 2 again, and add it back to 1. Should get the same notification.
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
  {
    ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));

    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    EXPECT_EQ("HierarchyChanged node=2,2 new_parent=1,1 old_parent=null",
              changes[0]);
    EXPECT_EQ("[node=2,2 parent=1,1]",
              ChangeNodeDescription(connection_->changes()));
  }
}

// Assertions for GetNodeTree.
TEST_F(ViewManagerTest, GetNodeTree) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  // Create 11 in first connection and make it a child of 1.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 11)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 11)));

  // Create two nodes in second connection, 2 and 3, both children of 1.
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 3)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2)));
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 3)));

  // Verifies GetNodeTree() on the root. The root connection sees all.
  {
    std::vector<TestNode> nodes;
    connection_->GetNodeTree(BuildNodeId(0, 1), &nodes);
    ASSERT_EQ(5u, nodes.size());
    EXPECT_EQ("node=0,1 parent=null", nodes[0].ToString());
    EXPECT_EQ("node=1,1 parent=0,1", nodes[1].ToString());
    EXPECT_EQ("node=1,11 parent=1,1", nodes[2].ToString());
    EXPECT_EQ("node=2,2 parent=1,1", nodes[3].ToString());
    EXPECT_EQ("node=2,3 parent=1,1", nodes[4].ToString());
  }

  // Verifies GetNodeTree() on the node 1,1. This does not include any children
  // as they are not from this connection.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=1,1 parent=null", nodes[0].ToString());
  }

  // Connection 2 shouldn't be able to get the root tree.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(0, 1), &nodes);
    ASSERT_EQ(0u, nodes.size());
  }
}

TEST_F(ViewManagerTest, SetNodeBounds) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  ASSERT_TRUE(connection_->SetNodeBounds(BuildNodeId(1, 1),
                                         gfx::Rect(0, 0, 100, 100)));

  connection2_->DoRunLoopUntilChangesCount(1);
  const Changes changes(ChangesToDescription1(connection2_->changes()));
  ASSERT_EQ(1u, changes.size());
  EXPECT_EQ("BoundsChanged node=1,1 old_bounds=0,0 0x0 new_bounds=0,0 100x100",
            changes[0]);

  // Should not be possible to change the bounds of a node created by another
  // connection.
  ASSERT_FALSE(connection2_->SetNodeBounds(BuildNodeId(1, 1),
                                           gfx::Rect(0, 0, 0, 0)));
}

// Verify AddNode fails when trying to manipulate nodes in other roots.
TEST_F(ViewManagerTest, CantMoveNodesFromOtherRoot) {
  // Create 1 and 2 in the first connection.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  // Try to move 2 to be a child of 1 from connection 2. This should fail as 2
  // should not be able to access 1.
  ASSERT_FALSE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2)));

  // Try to reparent 1 to the root. A connection is not allowed to reparent its
  // roots.
  ASSERT_FALSE(connection2_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
}

// Verify RemoveNodeFromParent fails for nodes that are descendants of the
// roots.
TEST_F(ViewManagerTest, CantRemoveNodesInOtherRoots) {
  // Create 1 and 2 in the first connection and parent both to the root.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));

  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 2)));

  // Establish the second connection and give it the root 1.
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  // Connection 2 should not be able to remove node 2 or 1 from its parent.
  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 2)));
  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 1)));

  // Create nodes 10 and 11 in 2.
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 10)));
  ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 11)));

  // Parent 11 to 10.
  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(2, 10), BuildNodeId(2, 11)));
  // Remove 11 from 10.
  ASSERT_TRUE(connection2_->RemoveNodeFromParent( BuildNodeId(2, 11)));

  // Verify nothing was actually removed.
  {
    std::vector<TestNode> nodes;
    connection_->GetNodeTree(BuildNodeId(0, 1), &nodes);
    ASSERT_EQ(3u, nodes.size());
    EXPECT_EQ("node=0,1 parent=null", nodes[0].ToString());
    EXPECT_EQ("node=1,1 parent=0,1", nodes[1].ToString());
    EXPECT_EQ("node=1,2 parent=0,1", nodes[2].ToString());
  }
}

// Verify GetNodeTree fails for nodes that are not descendants of the roots.
TEST_F(ViewManagerTest, CantGetNodeTreeOfOtherRoots) {
  // Create 1 and 2 in the first connection and parent both to the root.
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));

  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  std::vector<TestNode> nodes;

  // Should get nothing for the root.
  connection2_->GetNodeTree(BuildNodeId(0, 1), &nodes);
  ASSERT_TRUE(nodes.empty());

  // Should get nothing for node 2.
  connection2_->GetNodeTree(BuildNodeId(1, 2), &nodes);
  ASSERT_TRUE(nodes.empty());

  // Should get node 1 if asked for.
  connection2_->GetNodeTree(BuildNodeId(1, 1), &nodes);
  ASSERT_EQ(1u, nodes.size());
  EXPECT_EQ("node=1,1 parent=null", nodes[0].ToString());
}

TEST_F(ViewManagerTest, ConnectTwice) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));

  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  // Try to connect again to 1,1, this should fail as already connected to that
  // root.
  ASSERT_FALSE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL));

  // Connecting to 1,2 should succeed and end up in connection2.
  {
    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 2), kTestServiceURL));
    connection2_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection2_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("OnEmbed creator=mojo:test_url", changes[0]);
    EXPECT_EQ("[node=1,2 parent=null]",
              ChangeNodeDescription(connection2_->changes()));
  }
}

TEST_F(ViewManagerTest, OnNodeInput) {
  ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));

  // Dispatch an event to the node and verify its received.
  {
    EventPtr event(Event::New());
    event->action = static_cast<EventType>(1);
    connection_->view_manager()->DispatchOnViewInputEvent(
        BuildNodeId(1, 1),
        event.Pass());
    connection2_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection2_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("InputEvent node=1,1 event_action=1", changes[0]);
  }
}

TEST_F(ViewManagerTest, EmbedWithSameNodeId) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(connection_,
                                                   BuildNodeId(1, 1)));

  // Connection2 should have been told the node was deleted.
  {
    connection2_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection2_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("NodeDeleted node=1,1", changes[0]);
  }

  // Connection2 has no root. Verify it can't see node 1,1 anymore.
  {
    std::vector<TestNode> nodes;
    connection2_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    EXPECT_TRUE(nodes.empty());
  }
}

TEST_F(ViewManagerTest, EmbedWithSameNodeId2) {
  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));

  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(connection_,
                                                   BuildNodeId(1, 1)));

  // Connection2 should have been told the node was deleted.
  connection2_->DoRunLoopUntilChangesCount(1);
  connection2_->ClearChanges();

  // Create a node in the third connection and parent it to the root.
  ASSERT_TRUE(connection3_->CreateNode(BuildNodeId(3, 1)));
  ASSERT_TRUE(connection3_->AddNode(BuildNodeId(1, 1), BuildNodeId(3, 1)));

  // Connection 1 should have been told about the add (it owns the node).
  {
    connection_->DoRunLoopUntilChangesCount(1);
    const Changes changes(ChangesToDescription1(connection_->changes()));
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("HierarchyChanged node=3,1 new_parent=1,1 old_parent=null",
              changes[0]);
  }

  // Embed 1,1 back in connection 2.
  {
    // 2 should be told about the new embed.
    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL));
    connection2_->DoRunLoopUntilChangesCount(1);
    const std::vector<Change>& changes(connection2_->changes());
    ASSERT_EQ(1u, changes.size());
    EXPECT_EQ("OnEmbed creator=mojo:test_url",
              ChangesToDescription1(changes)[0]);
    EXPECT_EQ("[node=1,1 parent=null]",
              ChangeNodeDescription(changes));

    // And 3 should get a delete.
    connection3_->DoRunLoopUntilChangesCount(1);
    ASSERT_EQ(1u, connection3_->changes().size());
    EXPECT_EQ("NodeDeleted node=1,1",
              ChangesToDescription1(connection3_->changes())[0]);
  }

  // Connection3_ has no root. Verify it can't see node 1,1 anymore.
  {
    std::vector<TestNode> nodes;
    connection3_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    EXPECT_TRUE(nodes.empty());
  }

  // Verify 3,1 is no longer parented to 1,1. We have to do this from 1,1 as
  // connection3_ can no longer see 1,1.
  {
    std::vector<TestNode> nodes;
    connection_->GetNodeTree(BuildNodeId(1, 1), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=1,1 parent=null", nodes[0].ToString());
  }

  // Verify connection3_ can still see the node it created 3,1.
  {
    std::vector<TestNode> nodes;
    connection3_->GetNodeTree(BuildNodeId(3, 1), &nodes);
    ASSERT_EQ(1u, nodes.size());
    EXPECT_EQ("node=3,1 parent=null", nodes[0].ToString());
  }
}

// TODO(sky): add coverage of test that destroys connections and ensures other
// connections get deletion notification.

// TODO(sky): need to better track changes to initial connection. For example,
// that SetBounsdNodes/AddNode and the like don't result in messages to the
// originating connection.

}  // namespace service
}  // namespace mojo