Revert 25680c62320767f590d037d301edfe15e9c55650

remoting/protocol/connection_unittest.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker.h"
 #include "remoting/base/constants.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/protocol/audio_source.h"
 #include "remoting/protocol/audio_stream.h"
 #include "remoting/protocol/audio_stub.h"
 #include "remoting/protocol/fake_session.h"
 #include "remoting/protocol/fake_video_renderer.h"
 #include "remoting/protocol/ice_connection_to_client.h"
 #include "remoting/protocol/ice_connection_to_host.h"
 #include "remoting/protocol/protocol_mock_objects.h"
@@ skipping 154 matching lines @@
 };
 
 class FakeAudioPlayer : public AudioStub {
  public:
   FakeAudioPlayer() : weak_factory_(this) {}
   ~FakeAudioPlayer() override {}
 
   // AudioStub interface.
   void ProcessAudioPacket(std::unique_ptr<AudioPacket> packet,
                           const base::Closure& done) override {
-    base::ThreadChecker thread_checker_;
     EXPECT_EQ(AudioPacket::ENCODING_RAW, packet->encoding());
     EXPECT_EQ(AudioPacket::SAMPLING_RATE_48000, packet->sampling_rate());
     EXPECT_EQ(AudioPacket::BYTES_PER_SAMPLE_2, packet->bytes_per_sample());
     EXPECT_EQ(AudioPacket::CHANNELS_STEREO, packet->channels());
 
     data_.insert(data_.end(), packet->data(0).begin(), packet->data(0).end());
 
     if (run_loop_ && data_.size() >= samples_expected_ * 4)
       run_loop_->Quit();
 
@@ skipping 36 matching lines @@
     EXPECT_LE(kTestAudioSignalFrequencyLeftHz - 50, left_hz);
     EXPECT_GE(kTestAudioSignalFrequencyLeftHz + 50, left_hz);
     int right_hz = (right * kAudioSampleRate / (num_samples - skipped_samples));
     EXPECT_LE(kTestAudioSignalFrequencyRightHz - 50, right_hz);
     EXPECT_GE(kTestAudioSignalFrequencyRightHz + 50, right_hz);
   }
 
   base::WeakPtr<AudioStub> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
 
  private:
-  base::ThreadChecker thread_checker_;
   std::vector<char> data_;
   base::RunLoop* run_loop_ = nullptr;
   size_t samples_expected_ = 0;
 
   base::WeakPtrFactory<FakeAudioPlayer> weak_factory_;
 };
 
 }  // namespace
 
 class ConnectionTest : public testing::Test,
                        public testing::WithParamInterface<bool> {
  public:
-  ConnectionTest()
-      : video_encode_thread_("VideoEncode"),
-        audio_encode_thread_("AudioEncode"),
-        audio_decode_thread_("AudioDecode") {
-    video_encode_thread_.Start();
-    audio_encode_thread_.Start();
-    audio_decode_thread_.Start();
-  }
+  ConnectionTest() {}
 
   void DestroyHost() {
     host_connection_.reset();
     run_loop_->Quit();
   }
 
  protected:
   bool is_using_webrtc() { return GetParam(); }
 
   void SetUp() override {
@@ skipping 22 matching lines @@
     host_connection_->SetEventHandler(&host_event_handler_);
     host_connection_->set_clipboard_stub(&host_clipboard_stub_);
     host_connection_->set_host_stub(&host_stub_);
     host_connection_->set_input_stub(&host_input_stub_);
 
     // Setup client side.
     client_connection_->set_client_stub(&client_stub_);
     client_connection_->set_clipboard_stub(&client_clipboard_stub_);
     client_connection_->set_video_renderer(&client_video_renderer_);
 
-    client_connection_->InitializeAudio(audio_decode_thread_.task_runner(),
+    client_connection_->InitializeAudio(message_loop_.task_runner(),
                                         client_audio_player_.GetWeakPtr());
   }
 
   void Connect() {
     {
       testing::InSequence sequence;
       EXPECT_CALL(host_event_handler_, OnConnectionAuthenticating());
       EXPECT_CALL(host_event_handler_, OnConnectionAuthenticated());
     }
     EXPECT_CALL(host_event_handler_, OnConnectionChannelsConnected())
@@ skipping 121 matching lines @@
   MockConnectionToHostEventCallback client_event_handler_;
   MockClientStub client_stub_;
   MockClipboardStub client_clipboard_stub_;
   FakeVideoRenderer client_video_renderer_;
   FakeAudioPlayer client_audio_player_;
   std::unique_ptr<ConnectionToHost> client_connection_;
   FakeSession* client_session_;  // Owned by |client_connection_|.
   std::unique_ptr<FakeSession> owned_client_session_;
   bool client_connected_ = false;
 
-  base::Thread video_encode_thread_;
-  base::Thread audio_encode_thread_;
-  base::Thread audio_decode_thread_;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectionTest);
 };
 
 INSTANTIATE_TEST_CASE_P(Ice, ConnectionTest, ::testing::Values(false));
 INSTANTIATE_TEST_CASE_P(Webrtc, ConnectionTest, ::testing::Values(true));
 
 TEST_P(ConnectionTest, RejectConnection) {
   EXPECT_CALL(client_event_handler_,
               OnConnectionState(ConnectionToHost::CONNECTING, OK));
@@ skipping 203 matching lines @@
   auto capturer = base::MakeUnique<TestScreenCapturer>();
   capturer->FailNthFrame(1);
   auto video_stream = host_connection_->StartVideoStream(std::move(capturer));
 
   WaitNextVideoFrame();
   WaitNextVideoFrame();
 }
 
 }  // namespace protocol
 }  // namespace remoting