Restore thread name consistency for webrtc/p2p/ .

webrtc/p2p/base/transportcontroller_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 32 matching lines @@
 
 class TransportControllerTest : public testing::Test,
                                 public sigslot::has_slots<> {
  public:
   TransportControllerTest()
       : transport_controller_(new TransportControllerForTest()),
         signaling_thread_(rtc::Thread::Current()) {
     ConnectTransportControllerSignals();
   }
 
-  void CreateTransportControllerWithWorkerThread() {
-    if (!worker_thread_) {
-      worker_thread_.reset(new rtc::Thread());
-      worker_thread_->Start();
+  void CreateTransportControllerWithNetworkThread() {
+    if (!network_thread_) {
+      network_thread_.reset(new rtc::Thread());

[danilchap, 2016/10/05 14:56:13]

may be
network_thread_ = rtc::Thread::CreateWithSocketServer();
(it would be exactly same call underneath, just more explicit socket server part
is needed)

[johan, 2016/10/05 16:13:24]

Acknowledged.

+      network_thread_->Start();
     }
     transport_controller_.reset(
-        new TransportControllerForTest(worker_thread_.get()));
+        new TransportControllerForTest(network_thread_.get()));
     ConnectTransportControllerSignals();
   }
 
   void ConnectTransportControllerSignals() {
     transport_controller_->SignalConnectionState.connect(
         this, &TransportControllerTest::OnConnectionState);
     transport_controller_->SignalReceiving.connect(
         this, &TransportControllerTest::OnReceiving);
     transport_controller_->SignalGatheringState.connect(
         this, &TransportControllerTest::OnGatheringState);
@@ skipping 15 matching lines @@
   Candidate CreateCandidate(int component) {
     Candidate c;
     c.set_address(rtc::SocketAddress("192.168.1.1", 8000));
     c.set_component(1);
     c.set_protocol(UDP_PROTOCOL_NAME);
     c.set_priority(1);
     return c;
   }
 
   // Used for thread hopping test.
-  void CreateChannelsAndCompleteConnectionOnWorkerThread() {
-    worker_thread_->Invoke<void>(
+  void CreateChannelsAndCompleteConnectionOnNetworkThread() {
+    network_thread_->Invoke<void>(
         RTC_FROM_HERE,
         rtc::Bind(
             &TransportControllerTest::CreateChannelsAndCompleteConnection_w,
             this));
   }
 
   void CreateChannelsAndCompleteConnection_w() {
     transport_controller_->SetIceRole(ICEROLE_CONTROLLING);
     FakeTransportChannel* channel1 = CreateChannel("audio", 1);
     ASSERT_NE(nullptr, channel1);
@@ skipping 60 matching lines @@
   void OnCandidatesGathered(const std::string& transport_name,
                             const Candidates& candidates) {
     if (!signaling_thread_->IsCurrent()) {
       signaled_on_non_signaling_thread_ = true;
     }
     candidates_[transport_name].insert(candidates_[transport_name].end(),
                                        candidates.begin(), candidates.end());
     ++candidates_signal_count_;
   }
 
-  std::unique_ptr<rtc::Thread> worker_thread_;  // Not used for most tests.
+  std::unique_ptr<rtc::Thread> network_thread_;  // Not used for most tests.
   std::unique_ptr<TransportControllerForTest> transport_controller_;
 
   // Information received from signals from transport controller.
   IceConnectionState connection_state_ = kIceConnectionConnecting;
   bool receiving_ = false;
   IceGatheringState gathering_state_ = kIceGatheringNew;
   // transport_name => candidates
   std::map<std::string, Candidates> candidates_;
   // Counts of each signal emitted.
   int connection_state_signal_count_ = 0;
@@ skipping 467 matching lines @@
   EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", local_desc, CA_OFFER, &err));
   transport_controller_->MaybeStartGathering();
 
   channel->SignalCandidateGathered(channel, CreateCandidate(1));
   EXPECT_EQ_WAIT(1, candidates_signal_count_, kTimeout);
   EXPECT_EQ(1U, candidates_["audio"].size());
 }
 
 TEST_F(TransportControllerTest, TestSignalingOccursOnSignalingThread) {
-  CreateTransportControllerWithWorkerThread();
-  CreateChannelsAndCompleteConnectionOnWorkerThread();
+  CreateTransportControllerWithNetworkThread();
+  CreateChannelsAndCompleteConnectionOnNetworkThread();
 
   // connecting --> connected --> completed
   EXPECT_EQ_WAIT(kIceConnectionCompleted, connection_state_, kTimeout);
   EXPECT_EQ(2, connection_state_signal_count_);
 
   EXPECT_TRUE_WAIT(receiving_, kTimeout);
   EXPECT_EQ(1, receiving_signal_count_);
 
   // new --> gathering --> complete
   EXPECT_EQ_WAIT(kIceGatheringComplete, gathering_state_, kTimeout);
@@ skipping 66 matching lines @@
   // The endpoint that initiated an ICE restart should keep the existing role.
   TransportDescription ice_restart_desc(std::vector<std::string>(), kIceUfrag3,
                                         kIcePwd3, ICEMODE_FULL,
                                         CONNECTIONROLE_ACTPASS, nullptr);
   EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", ice_restart_desc, CA_OFFER, &err));
   EXPECT_EQ(ICEROLE_CONTROLLED, channel->GetIceRole());
 }
 
 }  // namespace cricket {