Updated latency fixture and refactored connection helper

remoting/test/app_remoting_latency_test_fixture.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 "remoting/test/app_remoting_latency_test_fixture.h"
 
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/usb_key_codes.h"
 #include "remoting/test/app_remoting_connection_helper.h"
 #include "remoting/test/app_remoting_test_driver_environment.h"
+#include "remoting/test/rgb_value.h"
 #include "remoting/test/test_chromoting_client.h"
 #include "remoting/test/test_video_renderer.h"
 
 namespace remoting {
 namespace test {
 
 AppRemotingLatencyTestFixture::AppRemotingLatencyTestFixture()
     : timer_(new base::Timer(true, false)) {
   // NOTE: Derived fixture must initialize application details in constructor.
 }
 
 AppRemotingLatencyTestFixture::~AppRemotingLatencyTestFixture() {
 }
 
 void AppRemotingLatencyTestFixture::SetUp() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<TestVideoRenderer> test_video_renderer(new TestVideoRenderer());
   test_video_renderer_ = test_video_renderer->GetWeakPtr();
 
   scoped_ptr<TestChromotingClient> test_chromoting_client(
       new TestChromotingClient(test_video_renderer.Pass()));
 
+  test_chromoting_client->AddRemoteConnectionObserver(this);
+
   connection_helper_.reset(
       new AppRemotingConnectionHelper(GetApplicationDetails()));
   connection_helper_->Initialize(test_chromoting_client.Pass());
 
   if (!connection_helper_->StartConnection()) {
     LOG(ERROR) << "Remote host connection could not be established.";
     FAIL();
   }
+
+  if (!PrepareApplicationForTesting()) {
+    LOG(ERROR) << "New document could not be created.";

[joedow, 2015/07/24 13:50:58]

Please fix error message, we don't know if creating a new document is what the
derived fixture attempted to do.

[liaoyuke, 2015/07/25 01:43:49]

I don't think so, the error message should come from the unittests, but I'll
re-try and fix it.

+    FAIL();
+  }
 }
 
 void AppRemotingLatencyTestFixture::TearDown() {
   // Only reset application state when remote host connection is established.
   if (connection_helper_->ConnectionIsReadyForTest()) {
     ResetApplicationState();
   }
 
+  connection_helper_->GetTestChromotingClient()->RemoveRemoteConnectionObserver(
+      this);
   connection_helper_.reset();
 }
 
 WaitForImagePatternMatchCallback
 AppRemotingLatencyTestFixture::SetExpectedImagePattern(
     const webrtc::DesktopRect& expected_rect,
-    uint32_t expected_color) {
+    const RGBValue& expected_color) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<base::RunLoop> run_loop(new base::RunLoop());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&TestVideoRenderer::ExpectAverageColorInRect,
                             test_video_renderer_, expected_rect, expected_color,
                             run_loop->QuitClosure()));
 
   return base::Bind(&AppRemotingLatencyTestFixture::WaitForImagePatternMatch,
@@ skipping 12 matching lines @@
   run_loop->Run();
 
   // Image pattern is matched if we stopped because of the reply not the timer.
   bool image_pattern_is_matched = (timer_->IsRunning());
   timer_->Stop();
   run_loop.reset();
 
   return image_pattern_is_matched;
 }
 
+void AppRemotingLatencyTestFixture::HostMessageReceived(
+    const protocol::ExtensionMessage& message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!host_message_received_callback_.is_null()) {
+    host_message_received_callback_.Run(message);
+  }
+}
+
 void AppRemotingLatencyTestFixture::PressKey(uint32_t usb_keycode,
                                              bool pressed) {
   remoting::protocol::KeyEvent event;
   event.set_usb_keycode(usb_keycode);
   event.set_pressed(pressed);
   connection_helper_->input_stub()->InjectKeyEvent(event);
 }
 
 void AppRemotingLatencyTestFixture::PressAndReleaseKey(uint32_t usb_keycode) {
   PressKey(usb_keycode, true);
@@ skipping 41 matching lines @@
 
   run_loop_.reset(new base::RunLoop());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, run_loop_->QuitClosure(), base::TimeDelta::FromSeconds(2));
   run_loop_->Run();
   run_loop_.reset();
 }
 
 }  // namespace test
 }  // namespace remoting