Rename ApplicationDelegate to ShellClient

components/html_viewer/html_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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 const char kAddFrameWithEmptyPageScript[] =
     "var iframe = document.createElement(\"iframe\");"
     "iframe.src = \"http://127.0.0.1:%u/empty_page.html\";"
     "document.body.appendChild(iframe);";
 
 void OnGotContentHandlerForRoot(bool* got_callback) {
   *got_callback = true;
   ignore_result(WindowServerTestBase::QuitRunLoop());
 }
 
-mojo::ApplicationConnection* ApplicationConnectionForFrame(Frame* frame) {
-  return static_cast<FrameConnection*>(frame->user_data())
-      ->application_connection();
+mojo::Connection* ConnectionForFrame(Frame* frame) {
+  return static_cast<FrameConnection*>(frame->user_data())->connection();
 }
 
-std::string GetFrameText(ApplicationConnection* connection) {
+std::string GetFrameText(Connection* connection) {
   html_viewer::TestHTMLViewerPtr test_html_viewer;
   connection->ConnectToService(&test_html_viewer);
   std::string result;
   test_html_viewer->GetContentAsText([&result](const String& mojo_string) {
     result = mojo_string;
     ASSERT_TRUE(WindowServerTestBase::QuitRunLoop());
   });
   if (!WindowServerTestBase::DoRunLoopWithTimeout())
     ADD_FAILURE() << "Timed out waiting for execute to complete";
   //  test_html_viewer.WaitForIncomingResponse();
   return result;
 }
 
-scoped_ptr<base::Value> ExecuteScript(ApplicationConnection* connection,
+scoped_ptr<base::Value> ExecuteScript(Connection* connection,
                                       const std::string& script) {
   html_viewer::TestHTMLViewerPtr test_html_viewer;
   connection->ConnectToService(&test_html_viewer);
   scoped_ptr<base::Value> result;
   test_html_viewer->ExecuteScript(script, [&result](const String& json_string) {
     result = base::JSONReader::Read(json_string.To<std::string>());
     ASSERT_TRUE(WindowServerTestBase::QuitRunLoop());
   });
   if (!WindowServerTestBase::DoRunLoopWithTimeout())
     ADD_FAILURE() << "Timed out waiting for execute to complete";
@@ skipping 90 matching lines @@
   // script) a frame showing the same empty page.
   Frame* LoadEmptyPageAndCreateFrame() {
     mus::Window* embed_window = window_manager()->NewWindow();
     frame_tree_delegate_.reset(new TestFrameTreeDelegateImpl(shell()));
     FrameConnection* root_connection = InitFrameTree(
         embed_window, "http://127.0.0.1:%u/empty_page2.html");
     if (!root_connection) {
       ADD_FAILURE() << "unable to establish root connection";
       return nullptr;
     }
-    const std::string frame_text =
-        GetFrameText(root_connection->application_connection());
+    const std::string frame_text = GetFrameText(root_connection->connection());
     if (frame_text != "child2") {
       ADD_FAILURE() << "unexpected text " << frame_text;
       return nullptr;
     }
 
     return CreateEmptyChildFrame(frame_tree_->root());
   }
 
   Frame* CreateEmptyChildFrame(Frame* parent) {
     const size_t initial_frame_count = parent->children().size();
     // Dynamically add a new frame.
-    ExecuteScript(ApplicationConnectionForFrame(parent),
+    ExecuteScript(ConnectionForFrame(parent),
                   AddPortToString(kAddFrameWithEmptyPageScript));
 
     frame_tree_delegate_->WaitForChildFrameCount(parent,
                                                  initial_frame_count + 1);
     if (HasFatalFailure())
       return nullptr;
 
     return parent->FindFrame(parent->window()->children().back()->id());
   }
 
@@ skipping 62 matching lines @@
 #define MAYBE_PageWithSingleFrame PageWithSingleFrame
 #endif
 TEST_F(HTMLFrameTest, MAYBE_PageWithSingleFrame) {
   mus::Window* embed_window = window_manager()->NewWindow();
 
   FrameConnection* root_connection = InitFrameTree(
       embed_window, "http://127.0.0.1:%u/page_with_single_frame.html");
   ASSERT_TRUE(root_connection);
 
   ASSERT_EQ("Page with single frame",
-            GetFrameText(root_connection->application_connection()));
+            GetFrameText(root_connection->connection()));
 
   ASSERT_NO_FATAL_FAILURE(
       frame_tree_delegate_->WaitForChildFrameCount(frame_tree_->root(), 1u));
 
   ASSERT_EQ(1u, embed_window->children().size());
   Frame* child_frame =
       frame_tree_->root()->FindFrame(embed_window->children()[0]->id());
   ASSERT_TRUE(child_frame);
 
   ASSERT_EQ("child",
             GetFrameText(static_cast<FrameConnection*>(child_frame->user_data())
-                             ->application_connection()));
+                             ->connection()));
 }
 
 // Creates two frames. The parent navigates the child frame by way of changing
 // the location of the child frame.
 // Crashes on linux_chromium_rel_ng only. http://crbug.com/567337
 #if defined(OS_LINUX)
 #define MAYBE_ChangeLocationOfChildFrame DISABLED_ChangeLocationOfChildFrame
 #else
 #define MAYBE_ChangeLocationOfChildFrame ChangeLocationOfChildFrame
 #endif
 TEST_F(HTMLFrameTest, MAYBE_ChangeLocationOfChildFrame) {
   mus::Window* embed_window = window_manager()->NewWindow();
 
   ASSERT_TRUE(InitFrameTree(
       embed_window, "http://127.0.0.1:%u/page_with_single_frame.html"));
 
   // page_with_single_frame contains a child frame. The child frame should
   // create a new View and Frame.
   ASSERT_NO_FATAL_FAILURE(
       frame_tree_delegate_->WaitForChildFrameCount(frame_tree_->root(), 1u));
 
   Frame* child_frame = frame_tree_->root()->children().back();
 
   ASSERT_EQ("child",
             GetFrameText(static_cast<FrameConnection*>(child_frame->user_data())
-                             ->application_connection()));
+                             ->connection()));
 
   // Change the location and wait for the navigation to occur.
   const char kNavigateFrame[] =
       "window.frames[0].location = "
       "'http://127.0.0.1:%u/empty_page2.html'";
   frame_tree_delegate_->ClearGotNavigate(child_frame);
-  ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+  ExecuteScript(ConnectionForFrame(frame_tree_->root()),
                 AddPortToString(kNavigateFrame));
   ASSERT_TRUE(frame_tree_delegate_->WaitForFrameNavigation(child_frame));
 
   // There should still only be one frame.
   ASSERT_EQ(1u, frame_tree_->root()->children().size());
 
   // The navigation should have changed the text of the frame.
   ASSERT_TRUE(child_frame->user_data());
   ASSERT_EQ("child2",
             GetFrameText(static_cast<FrameConnection*>(child_frame->user_data())
-                             ->application_connection()));
+                             ->connection()));
 }
 
 TEST_F(HTMLFrameTest, DynamicallyAddFrameAndVerifyParent) {
   Frame* child_frame = LoadEmptyPageAndCreateFrame();
   ASSERT_TRUE(child_frame);
 
-  mojo::ApplicationConnection* child_frame_connection =
-      ApplicationConnectionForFrame(child_frame);
+  mojo::Connection* child_frame_connection = ConnectionForFrame(child_frame);
 
   ASSERT_EQ("child", GetFrameText(child_frame_connection));
   // The child's parent should not be itself:
   const char kGetWindowParentNameScript[] =
       "window.parent == window ? 'parent is self' : 'parent not self';";
   scoped_ptr<base::Value> parent_value(
       ExecuteScript(child_frame_connection, kGetWindowParentNameScript));
   ASSERT_TRUE(parent_value->IsType(base::Value::TYPE_LIST));
   base::ListValue* parent_list;
   ASSERT_TRUE(parent_value->GetAsList(&parent_list));
   ASSERT_EQ(1u, parent_list->GetSize());
   std::string parent_name;
   ASSERT_TRUE(parent_list->GetString(0u, &parent_name));
   EXPECT_EQ("parent not self", parent_name);
 }
 
 TEST_F(HTMLFrameTest, DynamicallyAddFrameAndSeeNameChange) {
   Frame* child_frame = LoadEmptyPageAndCreateFrame();
   ASSERT_TRUE(child_frame);
 
-  mojo::ApplicationConnection* child_frame_connection =
-      ApplicationConnectionForFrame(child_frame);
+  mojo::Connection* child_frame_connection = ConnectionForFrame(child_frame);
 
   // Change the name of the child's window.
   ExecuteScript(child_frame_connection, "window.name = 'new_child';");
 
   // Eventually the parent should see the change. There is no convenient way
   // to observe this change, so we repeatedly ask for it and timeout if we
   // never get the right value.
   const base::TimeTicks start_time(base::TimeTicks::Now());
   std::string find_window_result;
   do {
     find_window_result.clear();
     scoped_ptr<base::Value> script_value(
-        ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+        ExecuteScript(ConnectionForFrame(frame_tree_->root()),
                       "window.frames['new_child'] != null ? 'found frame' : "
                       "'unable to find frame';"));
     if (script_value->IsType(base::Value::TYPE_LIST)) {
       base::ListValue* script_value_as_list;
       if (script_value->GetAsList(&script_value_as_list) &&
           script_value_as_list->GetSize() == 1) {
         script_value_as_list->GetString(0u, &find_window_result);
       }
     }
   } while (find_window_result != "found frame" &&
@@ skipping 16 matching lines @@
   const char kGetChildChildFrameCount[] =
       "if (window.frames.length > 0)"
       "  window.frames[0].frames.length.toString();"
       "else"
       "  '0';";
   const base::TimeTicks start_time(base::TimeTicks::Now());
   std::string child_child_frame_count;
   do {
     child_child_frame_count.clear();
     scoped_ptr<base::Value> script_value(
-        ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+        ExecuteScript(ConnectionForFrame(frame_tree_->root()),
                       kGetChildChildFrameCount));
     if (script_value->IsType(base::Value::TYPE_LIST)) {
       base::ListValue* script_value_as_list;
       if (script_value->GetAsList(&script_value_as_list) &&
           script_value_as_list->GetSize() == 1) {
         script_value_as_list->GetString(0u, &child_child_frame_count);
       }
     }
   } while (child_child_frame_count != "1" &&
            base::TimeTicks::Now() - start_time <
                TestTimeouts::action_timeout());
   EXPECT_EQ("1", child_child_frame_count);
 
   // Remove the child's child and make sure the root doesn't see it anymore.
   const char kRemoveLastIFrame[] =
       "document.body.removeChild(document.body.lastChild);";
-  ExecuteScript(ApplicationConnectionForFrame(child_frame), kRemoveLastIFrame);
+  ExecuteScript(ConnectionForFrame(child_frame), kRemoveLastIFrame);
   do {
     child_child_frame_count.clear();
     scoped_ptr<base::Value> script_value(
-        ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+        ExecuteScript(ConnectionForFrame(frame_tree_->root()),
                       kGetChildChildFrameCount));
     if (script_value->IsType(base::Value::TYPE_LIST)) {
       base::ListValue* script_value_as_list;
       if (script_value->GetAsList(&script_value_as_list) &&
           script_value_as_list->GetSize() == 1) {
         script_value_as_list->GetString(0u, &child_child_frame_count);
       }
     }
   } while (child_child_frame_count != "0" &&
            base::TimeTicks::Now() - start_time <
                TestTimeouts::action_timeout());
   ASSERT_EQ("0", child_child_frame_count);
 }
 
 // Verifies PostMessage() works across frames.
 TEST_F(HTMLFrameTest, PostMessage) {
   Frame* child_frame = LoadEmptyPageAndCreateFrame();
   ASSERT_TRUE(child_frame);
 
-  mojo::ApplicationConnection* child_frame_connection =
-      ApplicationConnectionForFrame(child_frame);
+  mojo::Connection* child_frame_connection = ConnectionForFrame(child_frame);
   ASSERT_EQ("child", GetFrameText(child_frame_connection));
 
   // Register an event handler in the child frame.
   const char kRegisterPostMessageHandler[] =
       "window.messageData = null;"
       "function messageFunction(event) {"
       "  window.messageData = event.data;"
       "}"
       "window.addEventListener('message', messageFunction, false);";
   ExecuteScript(child_frame_connection, kRegisterPostMessageHandler);
 
   // Post a message from the parent to the child.
   const char kPostMessageFromParent[] =
       "window.frames[0].postMessage('hello from parent', '*');";
-  ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+  ExecuteScript(ConnectionForFrame(frame_tree_->root()),
                 kPostMessageFromParent);
 
   // Wait for the child frame to see the message.
   const base::TimeTicks start_time(base::TimeTicks::Now());
   std::string message_in_child;
   do {
     const char kGetMessageData[] = "window.messageData;";
     scoped_ptr<base::Value> script_value(
         ExecuteScript(child_frame_connection, kGetMessageData));
     if (script_value->IsType(base::Value::TYPE_LIST)) {
       base::ListValue* script_value_as_list;
       if (script_value->GetAsList(&script_value_as_list) &&
           script_value_as_list->GetSize() == 1) {
         script_value_as_list->GetString(0u, &message_in_child);
       }
     }
   } while (message_in_child != "hello from parent" &&
            base::TimeTicks::Now() - start_time <
                TestTimeouts::action_timeout());
   EXPECT_EQ("hello from parent", message_in_child);
 }
 
 }  // namespace mojo