Updated latency fixture and refactored connection helper

remoting/test/app_remoting_connection_helper.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_connection_helper.h"
 
-#include "base/callback_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/test/app_remoting_test_driver_environment.h"
 #include "remoting/test/remote_application_details.h"
 #include "remoting/test/test_chromoting_client.h"
@@ skipping 12 matching lines @@
 AppRemotingConnectionHelper::AppRemotingConnectionHelper(
     const RemoteApplicationDetails& application_details)
     : application_details_(application_details),
       connection_is_ready_for_tests_(false),
       timer_(new base::Timer(true, false)) {
 }
 
 AppRemotingConnectionHelper::~AppRemotingConnectionHelper() {
   // |client_| destroys some of its members via DeleteSoon on the message loop's
   // TaskRunner so we need to run the loop until it has no more work to do.
-  client_->RemoveRemoteConnectionObserver(this);
+  if (!connection_is_ready_for_tests_) {
+    client_->RemoveRemoteConnectionObserver(this);
+  }
   client_.reset();
 
   base::RunLoop().RunUntilIdle();
 }
 
 void AppRemotingConnectionHelper::Initialize(
     scoped_ptr<TestChromotingClient> test_chromoting_client) {
   client_ = test_chromoting_client.Pass();
   client_->AddRemoteConnectionObserver(this);
 }
 
-void AppRemotingConnectionHelper::SetHostMessageReceivedCallback(
-      HostMessageReceivedCallback host_message_received_callback) {
-  host_message_received_callback_ = host_message_received_callback;
-}
-
 bool AppRemotingConnectionHelper::StartConnection() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
 
   RemoteHostInfo remote_host_info;
   remoting::test::AppRemotingSharedData->GetRemoteHostInfoForApplicationId(
       application_details_.application_id, &remote_host_info);
 
   if (!remote_host_info.IsReadyForConnection()) {
     return false;
@@ skipping 71 matching lines @@
   }
 }
 
 void AppRemotingConnectionHelper::HostMessageReceived(
     const protocol::ExtensionMessage& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VLOG(2) << "HostMessage received by HostMessageReceived()."
           << " type: " << message.type() << " data: " << message.data();
 
-  // If a callback is not registered, then the message is passed to a default
-  // handler for the class based on the message type.
-  if (!host_message_received_callback_.is_null()) {
-    base::ResetAndReturn(&host_message_received_callback_).Run(message);
-  } else if (message.type() == "onWindowAdded") {
+  if (message.type() == "onWindowAdded") {
     HandleOnWindowAddedMessage(message);
   } else {
     VLOG(2) << "HostMessage not handled by HostMessageReceived().";
   }
 }
 
 void AppRemotingConnectionHelper::SendClientConnectionDetailsToHost() {
   // First send an access token which will be used for Google Drive access.
   protocol::ExtensionMessage message;
   message.set_type("accessToken");
@@ skipping 39 matching lines @@
   std::string current_window_title;
   message_data->GetString("title", &current_window_title);
   if (current_window_title == kHostProcessWindowTitle) {
     LOG(ERROR) << "Host Process Window is visible, this likely means that the "
                << "underlying application is in a bad state, YMMV.";
   }
 
   std::string main_window_title = application_details_.main_window_title;
   if (current_window_title.find_first_of(main_window_title) == 0) {
     connection_is_ready_for_tests_ = true;
+    client_->RemoveRemoteConnectionObserver(this);
 
     if (timer_->IsRunning()) {
       timer_->Stop();
     }
 
     DCHECK(run_loop_);
     // Now that the main window is visible, give the app some time to settle
     // before signaling that it is ready to run tests.
     timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(2),
                   run_loop_->QuitClosure());
   }
 }
 
 }  // namespace test
 }  // namespace remoting