Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

chrome/browser/net/http_pipelining_compatibility_client_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/net/http_pipelining_compatibility_client.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::HistogramBase;
 using base::HistogramSamples;
@@ skipping 44 matching lines @@
 using content::BrowserThread;
 using testing::_;
 using testing::Field;
 using testing::Invoke;
 using testing::Return;
 using testing::StrEq;
 
 class HttpPipeliningCompatibilityClientTest : public testing::Test {
  public:
   HttpPipeliningCompatibilityClientTest()
-      : test_server_(net::SpawnedTestServer::TYPE_HTTP,
+      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+        test_server_(net::SpawnedTestServer::TYPE_HTTP,
                      net::SpawnedTestServer::kLocalhost,
                      base::FilePath(FILE_PATH_LITERAL(
-                         "chrome/test/data/http_pipelining"))),
-        io_thread_(BrowserThread::IO, &message_loop_) {
+                         "chrome/test/data/http_pipelining"))) {
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     // Start up a histogram recorder.
     // TODO(rtenneti): Leaks StatisticsRecorder and will update suppressions.
     base::StatisticsRecorder::Initialize();
     ASSERT_TRUE(test_server_.Start());
     context_ = new net::TestURLRequestContextGetter(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
     context_->AddRef();
 
     for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
       const char* name = kHistogramNames[i];
       scoped_ptr<HistogramSamples> samples = GetHistogram(name);
       if (samples.get() && samples->TotalCount() > 0) {
         original_samples_[name] = samples.release();
       }
     }
   }
 
   virtual void TearDown() OVERRIDE {
     BrowserThread::ReleaseSoon(BrowserThread::IO, FROM_HERE, context_);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     STLDeleteValues(&original_samples_);
   }
 
   void RunTest(
       std::vector<RequestInfo> requests,
       HttpPipeliningCompatibilityClient::Options options) {
     HttpPipeliningCompatibilityClient client(NULL);
     net::TestCompletionCallback callback;
     client.Start(test_server_.GetURL(std::string()).spec(),
                  requests,
@@ skipping 74 matching lines @@
     if (ContainsKey(original_samples_, name)) {
       samples->Subtract(*(original_samples_[name]));
     }
 
     EXPECT_EQ(expected_count, samples->TotalCount()) << name;
     if (expected_count > 0) {
       EXPECT_EQ(expected_count, samples->GetCount(expected_value)) << name;
     }
   }
 
-  base::MessageLoopForIO message_loop_;
+  content::TestBrowserThreadBundle thread_bundle_;
   net::SpawnedTestServer test_server_;
   net::TestURLRequestContextGetter* context_;
-  content::TestBrowserThread io_thread_;
 
  private:
   scoped_ptr<HistogramSamples> GetHistogram(const char* name) {
     scoped_ptr<HistogramSamples> samples;
     HistogramBase* cached_histogram = NULL;
     HistogramBase* current_histogram =
         base::StatisticsRecorder::FindHistogram(name);
     if (ContainsKey(histograms_, name)) {
       cached_histogram = histograms_[name];
     }
@@ skipping 367 matching lines @@
   callback.WaitForResult();
 
   ExpectHistogramCount(1, false, FIELD_CANARY);
   ExpectHistogramCount(0, false, FIELD_SUCCESS);
   ExpectHistogramCount(0, true, FIELD_SUCCESS);
 }
 
 }  // anonymous namespace
 
 }  // namespace chrome_browser_net