Removed RTCStatsCollector::ProducePartialResultsOnWorkerThread.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 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 378 matching lines @@
     GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback>(this));
     EXPECT_TRUE_WAIT(HasVerifiedResults(), kGetStatsReportTimeoutMs);
   }
 
   bool HasVerifiedResults() {
     EXPECT_TRUE(signaling_thread_->IsCurrent());
     rtc::CritScope cs(&lock_);
     if (!delivered_report_)
       return false;
     EXPECT_EQ(produced_on_signaling_thread_, 1);
-    EXPECT_EQ(produced_on_worker_thread_, 1);
     EXPECT_EQ(produced_on_network_thread_, 1);
 
     EXPECT_TRUE(delivered_report_->Get("SignalingThreadStats"));
-    EXPECT_TRUE(delivered_report_->Get("WorkerThreadStats"));
     EXPECT_TRUE(delivered_report_->Get("NetworkThreadStats"));
 
     produced_on_signaling_thread_ = 0;
-    produced_on_worker_thread_ = 0;
     produced_on_network_thread_ = 0;
     delivered_report_ = nullptr;
     return true;
   }
 
  protected:
   FakeRTCStatsCollector(
       PeerConnection* pc,
       int64_t cache_lifetime)
       : RTCStatsCollector(pc, cache_lifetime),
         signaling_thread_(pc->session()->signaling_thread()),
         worker_thread_(pc->session()->worker_thread()),
         network_thread_(pc->session()->network_thread()) {
   }
 
   void ProducePartialResultsOnSignalingThread(int64_t timestamp_us) override {
     EXPECT_TRUE(signaling_thread_->IsCurrent());
     {
       rtc::CritScope cs(&lock_);
       EXPECT_FALSE(delivered_report_);
       ++produced_on_signaling_thread_;
     }
 
     rtc::scoped_refptr<RTCStatsReport> signaling_report =
         RTCStatsReport::Create(0);
     signaling_report->AddStats(std::unique_ptr<const RTCStats>(
         new RTCTestStats("SignalingThreadStats", timestamp_us)));
     AddPartialResults(signaling_report);
   }
-  void ProducePartialResultsOnWorkerThread(int64_t timestamp_us) override {
-    EXPECT_TRUE(worker_thread_->IsCurrent());
-    {
-      rtc::CritScope cs(&lock_);
-      EXPECT_FALSE(delivered_report_);
-      ++produced_on_worker_thread_;
-    }
-
-    rtc::scoped_refptr<RTCStatsReport> worker_report =
-        RTCStatsReport::Create(0);
-    worker_report->AddStats(std::unique_ptr<const RTCStats>(
-        new RTCTestStats("WorkerThreadStats", timestamp_us)));
-    AddPartialResults(worker_report);
-  }
   void ProducePartialResultsOnNetworkThread(int64_t timestamp_us) override {
     EXPECT_TRUE(network_thread_->IsCurrent());
     {
       rtc::CritScope cs(&lock_);
       EXPECT_FALSE(delivered_report_);
       ++produced_on_network_thread_;
     }
 
     rtc::scoped_refptr<RTCStatsReport> network_report =
         RTCStatsReport::Create(0);
     network_report->AddStats(std::unique_ptr<const RTCStats>(
         new RTCTestStats("NetworkThreadStats", timestamp_us)));
     AddPartialResults(network_report);
   }
 
  private:
   rtc::Thread* const signaling_thread_;
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
 
   rtc::CriticalSection lock_;
   rtc::scoped_refptr<const RTCStatsReport> delivered_report_;
   int produced_on_signaling_thread_ = 0;
-  int produced_on_worker_thread_ = 0;
   int produced_on_network_thread_ = 0;
 };
 
 class RTCStatsCollectorTest : public testing::Test {
  public:
   RTCStatsCollectorTest()
     : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()),
       collector_(RTCStatsCollector::Create(
           &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) {
   }
@@ skipping 1422 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc