Remove local test timeouts in SearchHistoryTest.

chrome/browser/ui/app_list/search/history_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
-#include "base/timer/timer.h"
 #include "chrome/browser/ui/app_list/search/history.h"
 #include "chrome/browser/ui/app_list/search/history_data.h"
 #include "chrome/browser/ui/app_list/search/history_data_observer.h"
 #include "chrome/browser/ui/app_list/search/history_data_store.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace app_list {
 namespace test {
 
 namespace {
 
 const size_t kMaxPrimary = 3;
 const size_t kMaxSecondary = 2;
 
 // HistoryDataLoadWaiter waits for give |data| to be loaded from underlying
 // store on the blocking pool. The waiter waits on the main message loop until
 // OnHistoryDataLoadedFromStore() is invoked or the maximum allowed wait time
 // has passed.
 class HistoryDataLoadWaiter : public HistoryDataObserver {
  public:
   explicit HistoryDataLoadWaiter(HistoryData* data) : data_(data)  {}
   virtual ~HistoryDataLoadWaiter() {}
 
-  void Wait(int timeout_ms) {
+  void Wait() {
     data_->AddObserver(this);
 
-    timer_.Start(FROM_HERE,
-                 base::TimeDelta::FromMilliseconds(timeout_ms),
-                 this,
-                 &HistoryDataLoadWaiter::OnTimeOut);
-
     run_loop_.reset(new base::RunLoop);
     run_loop_->Run();
 
     data_->RemoveObserver(this);
   }
 
  private:
-  void OnTimeOut() {
-    run_loop_->Quit();
-  }
-
   // HistoryDataObserver overrides:
   virtual void OnHistoryDataLoadedFromStore() OVERRIDE {
     run_loop_->Quit();
   }
 
   HistoryData* data_;  // Not owned.
   scoped_ptr<base::RunLoop> run_loop_;
-  base::OneShotTimer<HistoryDataLoadWaiter> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryDataLoadWaiter);
 };
 
 // StoreFlushWaiter waits for the given |store| to flush its data to disk.
 // The flush and disk write happens on the blocking pool. The waiter waits
 // on the main message loop until the OnFlushed() is invoked or the maximum
 // allowed wait time has passed.
 class StoreFlushWaiter {
  public:
   explicit StoreFlushWaiter(HistoryDataStore* store) : store_(store) {}
   ~StoreFlushWaiter() {}
 
-  void Wait(int timeout_ms) {
+  void Wait() {
     store_->Flush(
         base::Bind(&StoreFlushWaiter::OnFlushed, base::Unretained(this)));
 
-    timer_.Start(FROM_HERE,
-                 base::TimeDelta::FromMilliseconds(timeout_ms),
-                 this,
-                 &StoreFlushWaiter::OnTimeOut);
-
     run_loop_.reset(new base::RunLoop);
     run_loop_->Run();
   }
 
  private:
-  void OnTimeOut() {
-    run_loop_->Quit();
-  }
-
   void OnFlushed() {
     run_loop_->Quit();
   }
 
   HistoryDataStore* store_;  // Not owned.
   scoped_ptr<base::RunLoop> run_loop_;
-  base::OneShotTimer<StoreFlushWaiter> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreFlushWaiter);
 };
 
 }  // namespace
 
 class SearchHistoryTest : public testing::Test {
  public:
   SearchHistoryTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {}
@@ skipping 10 matching lines @@
 
   void CreateHistory() {
     history_.reset(new History(profile_.get()));
 
     // Replace |data_| with test params.
     history_->data_->RemoveObserver(history_.get());
     history_->data_.reset(
         new HistoryData(history_->store_.get(), kMaxPrimary, kMaxSecondary));
     history_->data_->AddObserver(history_.get());
 
-    HistoryDataLoadWaiter waiter(history_->data_.get());
-    waiter.Wait(1000);
+    HistoryDataLoadWaiter(history_->data_.get()).Wait();
     ASSERT_TRUE(history_->IsReady());
   }
 
   void Flush() {
-    StoreFlushWaiter waiter(history_->store_.get());
-    waiter.Wait(1000);
+    StoreFlushWaiter(history_->store_.get()).Wait();
   }
 
   size_t GetKnownResults(const std::string& query) {
     known_results_ = history()->GetKnownResults(query).Pass();
     return known_results_->size();
   }
 
   KnownResultType GetResultType(const std::string& result_id) {
     return known_results_->find(result_id) != known_results_->end()
                ? (*known_results_.get())[result_id]
@@ skipping 158 matching lines @@
 
   // The oldest secondary is gone.
   EXPECT_EQ(UNKNOWN_RESULT, GetResultType("1"));
 
   // Touched oldest survived.
   EXPECT_EQ(PERFECT_SECONDARY, GetResultType("0"));
 }
 
 }  // namespace test
 }  // namespace app_list