Rename frame classes

components/web_view/frame_apptest.cc

 // Copyright 2015 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/web_view/frame.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 63 matching lines @@
   scoped_ptr<FrameConnection> frame_connection(new FrameConnection);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(app->url());
   base::RunLoop run_loop;
   frame_connection->Init(app, request.Pass(),
                          base::Bind(&OnGotIdCallback, &run_loop));
   run_loop.Run();
   return frame_connection;
 }
 
-class TestFrameTreeClient : public FrameTreeClient {
+class TestFrameClient : public mojom::FrameClient {
  public:
-  TestFrameTreeClient()
+  TestFrameClient()
       : connect_count_(0), last_dispatch_load_event_frame_id_(0) {}
-  ~TestFrameTreeClient() override {}
+  ~TestFrameClient() override {}
 
   int connect_count() const { return connect_count_; }
 
-  mojo::Array<FrameDataPtr> connect_frames() { return connect_frames_.Pass(); }
+  mojo::Array<mojom::FrameDataPtr> connect_frames() {
+    return connect_frames_.Pass();
+  }
 
-  mojo::Array<FrameDataPtr> adds() { return adds_.Pass(); }
+  mojo::Array<mojom::FrameDataPtr> adds() { return adds_.Pass(); }
 
   // Sets a callback to run once OnConnect() is received.
   void set_on_connect_callback(const base::Closure& closure) {
     on_connect_callback_ = closure;
   }
 
   void set_on_loading_state_changed_callback(const base::Closure& closure) {
     on_loading_state_changed_callback_ = closure;
   }
 
   void set_on_dispatch_load_event_callback(const base::Closure& closure) {
     on_dispatch_load_event_callback_ = closure;
   }
 
-  FrameTreeServer* server() { return server_.get(); }
+  mojom::Frame* server_frame() { return server_frame_.get(); }
 
-  mojo::InterfaceRequest<FrameTreeServer> GetFrameTreeServerRequest() {
-    return GetProxy(&server_);
+  mojo::InterfaceRequest<mojom::Frame> GetServerFrameRequest() {
+    return GetProxy(&server_frame_);
   }
 
   void last_loading_state_changed_notification(uint32_t* frame_id,
                                                bool* loading) const {
     *frame_id = last_loading_state_changed_notification_.frame_id;
     *loading = last_loading_state_changed_notification_.loading;
   }
 
   uint32_t last_dispatch_load_event_frame_id() const {
     return last_dispatch_load_event_frame_id_;
   }
 
-  // TestFrameTreeClient:
-  void OnConnect(FrameTreeServerPtr server,
+  // mojom::FrameClient:
+  void OnConnect(mojom::FramePtr frame,
                  uint32_t change_id,
                  uint32_t view_id,
-                 ViewConnectType view_connect_type,
-                 mojo::Array<FrameDataPtr> frames,
+                 mojom::ViewConnectType view_connect_type,
+                 mojo::Array<mojom::FrameDataPtr> frames,
                  const OnConnectCallback& callback) override {
     connect_count_++;
     connect_frames_ = frames.Pass();
-    if (server)
-      server_ = server.Pass();
+    if (frame)
+      server_frame_ = frame.Pass();
     callback.Run();
     if (!on_connect_callback_.is_null())
       on_connect_callback_.Run();
   }
-  void OnFrameAdded(uint32_t change_id, FrameDataPtr frame) override {
+  void OnFrameAdded(uint32_t change_id, mojom::FrameDataPtr frame) override {
     adds_.push_back(frame.Pass());
   }
   void OnFrameRemoved(uint32_t change_id, uint32_t frame_id) override {}
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_data) override {}
   void OnPostMessageEvent(uint32_t source_frame_id,
                           uint32_t target_frame_id,
-                          HTMLMessageEventPtr event) override {}
+                          mojom::HTMLMessageEventPtr event) override {}
   void OnWillNavigate() override {}
   void OnFrameLoadingStateChanged(uint32_t frame_id, bool loading) override {
     last_loading_state_changed_notification_.frame_id = frame_id;
     last_loading_state_changed_notification_.loading = loading;
 
     if (!on_loading_state_changed_callback_.is_null())
       on_loading_state_changed_callback_.Run();
   }
   void OnDispatchFrameLoadEvent(uint32_t frame_id) override {
     last_dispatch_load_event_frame_id_ = frame_id;
 
     if (!on_dispatch_load_event_callback_.is_null())
       on_dispatch_load_event_callback_.Run();
   }
 
  private:
   struct LoadingStateChangedNotification {
     LoadingStateChangedNotification() : frame_id(0), loading(false) {}
     ~LoadingStateChangedNotification() {}
 
     uint32_t frame_id;
     bool loading;
   };
 
   int connect_count_;
-  mojo::Array<FrameDataPtr> connect_frames_;
-  FrameTreeServerPtr server_;
-  mojo::Array<FrameDataPtr> adds_;
+  mojo::Array<mojom::FrameDataPtr> connect_frames_;
+  mojom::FramePtr server_frame_;
+  mojo::Array<mojom::FrameDataPtr> adds_;
   base::Closure on_connect_callback_;
   base::Closure on_loading_state_changed_callback_;
   base::Closure on_dispatch_load_event_callback_;
   LoadingStateChangedNotification last_loading_state_changed_notification_;
   uint32_t last_dispatch_load_event_frame_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestFrameTreeClient);
+  DISALLOW_COPY_AND_ASSIGN(TestFrameClient);
 };
 
 class FrameTest;
 
-// ViewAndFrame maintains the View and TestFrameTreeClient associated with
-// a single FrameTreeClient. In other words this maintains the data structures
+// ViewAndFrame maintains the View and TestFrameClient associated with
+// a single FrameClient. In other words this maintains the data structures
 // needed to represent a client side frame. To obtain one use
 // FrameTest::WaitForViewAndFrame().
 class ViewAndFrame : public mus::ViewTreeDelegate {
  public:
   ~ViewAndFrame() override {
     if (view_)
       delete view_->connection();
   }
 
   // The View associated with the frame.
   mus::View* view() { return view_; }
-  TestFrameTreeClient* test_frame_tree_client() {
-    return &test_frame_tree_client_;
-  }
-  FrameTreeServer* frame_tree_server() {
-    return test_frame_tree_client_.server();
+  TestFrameClient* test_frame_client() { return &test_frame_tree_client_; }
+  mojom::Frame* server_frame() {
+    return test_frame_tree_client_.server_frame();
   }
 
  private:
   friend class FrameTest;
 
   ViewAndFrame()
-      : view_(nullptr), frame_tree_binding_(&test_frame_tree_client_) {}
+      : view_(nullptr), frame_client_binding_(&test_frame_tree_client_) {}
 
   void set_view(View* view) { view_ = view; }
 
   // Runs a message loop until the view and frame data have been received.
   void WaitForViewAndFrame() { run_loop_.Run(); }
 
-  mojo::InterfaceRequest<FrameTreeServer> GetFrameTreeServerRequest() {
-    return test_frame_tree_client_.GetFrameTreeServerRequest();
+  mojo::InterfaceRequest<mojom::Frame> GetServerFrameRequest() {
+    return test_frame_tree_client_.GetServerFrameRequest();
   }
 
-  FrameTreeClientPtr GetFrameTreeClientPtr() {
-    FrameTreeClientPtr client_ptr;
-    frame_tree_binding_.Bind(GetProxy(&client_ptr));
+  mojom::FrameClientPtr GetFrameClientPtr() {
+    mojom::FrameClientPtr client_ptr;
+    frame_client_binding_.Bind(GetProxy(&client_ptr));
     return client_ptr.Pass();
   }
 
-  void Bind(mojo::InterfaceRequest<FrameTreeClient> request) {
-    ASSERT_FALSE(frame_tree_binding_.is_bound());
+  void Bind(mojo::InterfaceRequest<mojom::FrameClient> request) {
+    ASSERT_FALSE(frame_client_binding_.is_bound());
     test_frame_tree_client_.set_on_connect_callback(
         base::Bind(&ViewAndFrame::OnGotConnect, base::Unretained(this)));
-    frame_tree_binding_.Bind(request.Pass());
+    frame_client_binding_.Bind(request.Pass());
   }
 
   void OnGotConnect() { QuitRunLoopIfNecessary(); }
 
   void QuitRunLoopIfNecessary() {
     if (view_ && test_frame_tree_client_.connect_count())
       run_loop_.Quit();
   }
 
   // Overridden from ViewTreeDelegate:
   void OnEmbed(View* root) override {
     view_ = root;
     QuitRunLoopIfNecessary();
   }
   void OnConnectionLost(ViewTreeConnection* connection) override {
     view_ = nullptr;
   }
 
   mus::View* view_;
   base::RunLoop run_loop_;
-  TestFrameTreeClient test_frame_tree_client_;
-  mojo::Binding<FrameTreeClient> frame_tree_binding_;
+  TestFrameClient test_frame_tree_client_;
+  mojo::Binding<mojom::FrameClient> frame_client_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewAndFrame);
 };
 
 class FrameTest : public mojo::test::ApplicationTestBase,
                   public mojo::ApplicationDelegate,
                   public mus::ViewTreeDelegate,
                   public mojo::InterfaceFactory<mojo::ViewTreeClient>,
-                  public mojo::InterfaceFactory<FrameTreeClient> {
+                  public mojo::InterfaceFactory<mojom::FrameClient> {
  public:
   FrameTest() : most_recent_connection_(nullptr), window_manager_(nullptr) {}
 
   ViewTreeConnection* most_recent_connection() {
     return most_recent_connection_;
   }
 
  protected:
   ViewTreeConnection* window_manager() { return window_manager_; }
   TestFrameTreeDelegate* frame_tree_delegate() {
     return frame_tree_delegate_.get();
   }
   FrameTree* frame_tree() { return frame_tree_.get(); }
   ViewAndFrame* root_view_and_frame() { return root_view_and_frame_.get(); }
 
-  mojo::Binding<FrameTreeServer>* frame_tree_server_binding(Frame* frame) {
-    return frame->frame_tree_server_binding_.get();
-  }
-
   scoped_ptr<ViewAndFrame> NavigateFrame(ViewAndFrame* view_and_frame) {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(application_impl()->url());
-    view_and_frame->frame_tree_server()->RequestNavigate(
-        NAVIGATION_TARGET_TYPE_EXISTING_FRAME, view_and_frame->view()->id(),
-        request.Pass());
+    view_and_frame->server_frame()->RequestNavigate(
+        mojom::NAVIGATION_TARGET_TYPE_EXISTING_FRAME,
+        view_and_frame->view()->id(), request.Pass());
     return WaitForViewAndFrame();
   }
 
   // Creates a new shared frame as a child of |parent|.
   scoped_ptr<ViewAndFrame> CreateChildViewAndFrame(ViewAndFrame* parent) {
     mus::View* child_frame_view = parent->view()->connection()->CreateView();
     parent->view()->AddChild(child_frame_view);
 
     scoped_ptr<ViewAndFrame> view_and_frame(new ViewAndFrame);
     view_and_frame->set_view(child_frame_view);
 
     mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties;
     client_properties.mark_non_null();
-    parent->frame_tree_server()->OnCreatedFrame(
-        view_and_frame->GetFrameTreeServerRequest(),
-        view_and_frame->GetFrameTreeClientPtr(), child_frame_view->id(),
+    parent->server_frame()->OnCreatedFrame(
+        view_and_frame->GetServerFrameRequest(),
+        view_and_frame->GetFrameClientPtr(), child_frame_view->id(),
         client_properties.Pass());
     frame_tree_delegate()->WaitForCreateFrame();
     return HasFatalFailure() ? nullptr : view_and_frame.Pass();
   }
 
   // Runs a message loop until the data necessary to represent to a client side
   // frame has been obtained.
   scoped_ptr<ViewAndFrame> WaitForViewAndFrame() {
     DCHECK(!view_and_frame_);
     view_and_frame_.reset(new ViewAndFrame);
     view_and_frame_->WaitForViewAndFrame();
     return view_and_frame_.Pass();
   }
 
  private:
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) override {
     connection->AddService<mojo::ViewTreeClient>(this);
-    connection->AddService<FrameTreeClient>(this);
+    connection->AddService<mojom::FrameClient>(this);
     return true;
   }
 
   // Overridden from ViewTreeDelegate:
   void OnEmbed(View* root) override {
     most_recent_connection_ = root->connection();
     QuitRunLoop();
   }
   void OnConnectionLost(ViewTreeConnection* connection) override {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
     mus::CreateSingleViewTreeHost(application_impl(), this, &host_);
 
     ASSERT_TRUE(DoRunLoopWithTimeout());
     std::swap(window_manager_, most_recent_connection_);
 
     // Creates a FrameTree, which creates a single frame. Wait for the
-    // FrameTreeClient to be connected to.
+    // FrameClient to be connected to.
     frame_tree_delegate_.reset(new TestFrameTreeDelegate(application_impl()));
     scoped_ptr<FrameConnection> frame_connection =
         CreateFrameConnection(application_impl());
-    FrameTreeClient* frame_tree_client = frame_connection->frame_tree_client();
+    mojom::FrameClient* frame_client = frame_connection->frame_client();
     mojo::ViewTreeClientPtr view_tree_client =
         frame_connection->GetViewTreeClient();
     mus::View* frame_root_view = window_manager()->CreateView();
     window_manager()->GetRoot()->AddChild(frame_root_view);
     frame_tree_.reset(
         new FrameTree(0u, frame_root_view, view_tree_client.Pass(),
-                      frame_tree_delegate_.get(), frame_tree_client,
+                      frame_tree_delegate_.get(), frame_client,
                       frame_connection.Pass(), Frame::ClientPropertyMap()));
     root_view_and_frame_ = WaitForViewAndFrame();
   }
 
   // Overridden from testing::Test:
   void TearDown() override {
     root_view_and_frame_.reset();
     frame_tree_.reset();
     frame_tree_delegate_.reset();
     ApplicationTestBase::TearDown();
   }
 
   // Overridden from mojo::InterfaceFactory<mojo::ViewTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
       mojo::InterfaceRequest<mojo::ViewTreeClient> request) override {
     if (view_and_frame_) {
       mus::ViewTreeConnection::Create(view_and_frame_.get(), request.Pass());
     } else {
       mus::ViewTreeConnection::Create(this, request.Pass());
     }
   }
 
-  // Overridden from mojo::InterfaceFactory<FrameTreeClient>:
+  // Overridden from mojo::InterfaceFactory<mojom::FrameClient>:
   void Create(mojo::ApplicationConnection* connection,
-              mojo::InterfaceRequest<FrameTreeClient> request) override {
+              mojo::InterfaceRequest<mojom::FrameClient> request) override {
     ASSERT_TRUE(view_and_frame_);
     view_and_frame_->Bind(request.Pass());
   }
 
   scoped_ptr<TestFrameTreeDelegate> frame_tree_delegate_;
   scoped_ptr<FrameTree> frame_tree_;
   scoped_ptr<ViewAndFrame> root_view_and_frame_;
 
   mojo::ViewTreeHostPtr host_;
 
   // Used to receive the most recent view manager loaded by an embed action.
   ViewTreeConnection* most_recent_connection_;
   // The View Manager connection held by the window manager (app running at the
   // root view).
   ViewTreeConnection* window_manager_;
 
   scoped_ptr<ViewAndFrame> view_and_frame_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FrameTest);
 };
 
-// Verifies the FrameData supplied to the root FrameTreeClient::OnConnect().
+// Verifies the FrameData supplied to the root FrameClient::OnConnect().
 TEST_F(FrameTest, RootFrameClientConnectData) {
-  mojo::Array<FrameDataPtr> frames =
-      root_view_and_frame()->test_frame_tree_client()->connect_frames();
+  mojo::Array<mojom::FrameDataPtr> frames =
+      root_view_and_frame()->test_frame_client()->connect_frames();
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(root_view_and_frame()->view()->id(), frames[0]->frame_id);
   EXPECT_EQ(0u, frames[0]->parent_id);
 }
 
-// Verifies the FrameData supplied to a child FrameTreeClient::OnConnect().
+// Verifies the FrameData supplied to a child FrameClient::OnConnect().
 TEST_F(FrameTest, ChildFrameClientConnectData) {
   scoped_ptr<ViewAndFrame> child_view_and_frame(
       CreateChildViewAndFrame(root_view_and_frame()));
   ASSERT_TRUE(child_view_and_frame);
   // Initially created child frames don't get OnConnect().
-  EXPECT_EQ(0,
-            child_view_and_frame->test_frame_tree_client()->connect_count());
+  EXPECT_EQ(0, child_view_and_frame->test_frame_client()->connect_count());
 
   scoped_ptr<ViewAndFrame> navigated_child_view_and_frame =
       NavigateFrame(child_view_and_frame.get()).Pass();
 
-  mojo::Array<FrameDataPtr> frames_in_child =
-      navigated_child_view_and_frame->test_frame_tree_client()
-          ->connect_frames();
+  mojo::Array<mojom::FrameDataPtr> frames_in_child =
+      navigated_child_view_and_frame->test_frame_client()->connect_frames();
   EXPECT_EQ(child_view_and_frame->view()->id(),
             navigated_child_view_and_frame->view()->id());
   // We expect 2 frames. One for the root, one for the child.
   ASSERT_EQ(2u, frames_in_child.size());
   EXPECT_EQ(frame_tree()->root()->id(), frames_in_child[0]->frame_id);
   EXPECT_EQ(0u, frames_in_child[0]->parent_id);
   EXPECT_EQ(navigated_child_view_and_frame->view()->id(),
             frames_in_child[1]->frame_id);
   EXPECT_EQ(frame_tree()->root()->id(), frames_in_child[1]->parent_id);
 }
@@ skipping 16 matching lines @@
 }
 
 TEST_F(FrameTest, NotifyRemoteParentWithLoadingState) {
   scoped_ptr<ViewAndFrame> child_view_and_frame(
       CreateChildViewAndFrame(root_view_and_frame()));
   uint32_t child_frame_id = child_view_and_frame->view()->id();
 
   {
     base::RunLoop run_loop;
     root_view_and_frame()
-        ->test_frame_tree_client()
+        ->test_frame_client()
         ->set_on_loading_state_changed_callback(run_loop.QuitClosure());
 
-    child_view_and_frame->frame_tree_server()->LoadingStateChanged(true, .5);
+    child_view_and_frame->server_frame()->LoadingStateChanged(true, .5);
 
     run_loop.Run();
 
     uint32_t frame_id = 0;
     bool loading = false;
     root_view_and_frame()
-        ->test_frame_tree_client()
+        ->test_frame_client()
         ->last_loading_state_changed_notification(&frame_id, &loading);
     EXPECT_EQ(child_frame_id, frame_id);
     EXPECT_TRUE(loading);
   }
   {
     base::RunLoop run_loop;
     root_view_and_frame()
-        ->test_frame_tree_client()
+        ->test_frame_client()
         ->set_on_loading_state_changed_callback(run_loop.QuitClosure());
 
     ASSERT_TRUE(child_view_and_frame);
-    ASSERT_TRUE(child_view_and_frame->frame_tree_server());
+    ASSERT_TRUE(child_view_and_frame->server_frame());
 
-    child_view_and_frame->frame_tree_server()->LoadingStateChanged(false, 1);
+    child_view_and_frame->server_frame()->LoadingStateChanged(false, 1);
 
     run_loop.Run();
 
     uint32_t frame_id = 0;
     bool loading = false;
     root_view_and_frame()
-        ->test_frame_tree_client()
+        ->test_frame_client()
         ->last_loading_state_changed_notification(&frame_id, &loading);
     EXPECT_EQ(child_frame_id, frame_id);
     EXPECT_FALSE(loading);
   }
 }
 
 TEST_F(FrameTest, NotifyRemoteParentWithLoadEvent) {
   scoped_ptr<ViewAndFrame> child_view_and_frame(
       CreateChildViewAndFrame(root_view_and_frame()));
   uint32_t child_frame_id = child_view_and_frame->view()->id();
 
   base::RunLoop run_loop;
   root_view_and_frame()
-      ->test_frame_tree_client()
+      ->test_frame_client()
       ->set_on_dispatch_load_event_callback(run_loop.QuitClosure());
 
-  child_view_and_frame->frame_tree_server()->DispatchLoadEventToParent();
+  child_view_and_frame->server_frame()->DispatchLoadEventToParent();
 
   run_loop.Run();
 
   uint32_t frame_id = root_view_and_frame()
-                          ->test_frame_tree_client()
+                          ->test_frame_client()
                           ->last_dispatch_load_event_frame_id();
   EXPECT_EQ(child_frame_id, frame_id);
 }
 }  // namespace web_view