Conenct Chromoting plugin debug log to JS UI.

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task.h"
+#include "remoting/base/logger.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/host/in_memory_host_config.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 61 matching lines @@
         .WillByDefault(Return(&message_loop_));
     EXPECT_CALL(context_, main_message_loop())
         .Times(AnyNumber());
     EXPECT_CALL(context_, encode_message_loop())
         .Times(AnyNumber());
     EXPECT_CALL(context_, network_message_loop())
         .Times(AnyNumber());
     EXPECT_CALL(context_, ui_message_loop())
         .Times(AnyNumber());
 
+    logger_.reset(new Logger());
+
     context_.SetUITaskPostFunction(base::Bind(
         static_cast<void(MessageLoop::*)(
             const tracked_objects::Location&, Task*)>(&MessageLoop::PostTask),
         base::Unretained(&message_loop_)));
 
     Capturer* capturer = new CapturerFake();
     event_executor_ = new MockEventExecutor();
     curtain_ = new MockCurtain();
     disconnect_window_ = new MockDisconnectWindow();
     continue_window_ = new MockContinueWindow();
     local_input_monitor_ = new MockLocalInputMonitor();
     DesktopEnvironment* desktop =
         new DesktopEnvironment(&context_, capturer, event_executor_, curtain_,
                                disconnect_window_, continue_window_,
                                local_input_monitor_);
     MockAccessVerifier* access_verifier = new MockAccessVerifier();
 
     host_ = ChromotingHost::Create(&context_, config_,
-                                   desktop, access_verifier);
+                                   desktop, access_verifier, logger_.get());
     credentials_.set_type(protocol::PASSWORD);
     credentials_.set_username("user");
     credentials_.set_credential("password");
     connection_ = new MockConnectionToClient(
         &message_loop_, &handler_, &host_stub_, event_executor_);
     connection2_ = new MockConnectionToClient(
         &message_loop_, &handler_, &host_stub2_, &event_executor2_);
     session_.reset(new MockSession());
     session2_.reset(new MockSession());
     session_config_.reset(SessionConfig::CreateDefault());
@@ skipping 80 matching lines @@
                               scoped_refptr<ClientSession> session) {
     host->clients_.push_back(session);
   }
 
   void ShutdownHost() {
     host_->Shutdown(
         NewRunnableFunction(&PostQuitTask, &message_loop_));
   }
 
  protected:
+  scoped_ptr<Logger> logger_;
   MessageLoop message_loop_;
   MockConnectionToClientEventHandler handler_;
   scoped_refptr<ChromotingHost> host_;
   scoped_refptr<InMemoryHostConfig> config_;
   MockChromotingHostContext context_;
   protocol::LocalLoginCredentials credentials_;
   scoped_refptr<MockConnectionToClient> connection_;
   scoped_ptr<MockSession> session_;
   scoped_ptr<SessionConfig> session_config_;
   MockVideoStub video_stub_;
   MockClientStub client_stub_;
   MockHostStub host_stub_;
   scoped_refptr<MockConnectionToClient> connection2_;
   scoped_ptr<MockSession> session2_;
   scoped_ptr<SessionConfig> session_config2_;
   MockVideoStub video_stub2_;
   MockClientStub client_stub2_;
   MockHostStub host_stub2_;
   MockEventExecutor event_executor2_;
 
   // Owned by |host_|.
   MockEventExecutor* event_executor_;
   MockCurtain* curtain_;
   MockDisconnectWindow* disconnect_window_;
-  ContinueWindow* continue_window_;
+  MockContinueWindow* continue_window_;
   MockLocalInputMonitor* local_input_monitor_;
 };
 
 TEST_F(ChromotingHostTest, DISABLED_StartAndShutdown) {
   host_->Start();
 
   message_loop_.PostTask(
       FROM_HERE,NewRunnableMethod(
           host_.get(), &ChromotingHost::Shutdown,
           NewRunnableFunction(&PostQuitTask, &message_loop_)));
@@ skipping 244 matching lines @@
     EXPECT_CALL(*connection_.get(), Disconnect())
         .InSequence(s1, s2)
         .RetiresOnSaturation();
   }
   SimulateClientConnection(0, true);
   message_loop_.Run();
   host_->set_it2me(false);
   EXPECT_THAT(curtain_activated, false);
 }
 }  // namespace remoting