Remove gmock from DriveSchedulerTest.

chrome/browser/chromeos/drive/drive_scheduler_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/chromeos/drive/drive_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/file_util.h"
-#include "base/json/json_reader.h"
 #include "base/prefs/pref_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive_test_util.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/fake_drive_service.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using ::testing::AnyNumber;
-using ::testing::DoAll;
-using ::testing::Eq;
-using ::testing::Return;
-using ::testing::StrictMock;
-using ::testing::_;
-
 namespace drive {
 
 namespace {
 
-class MockNetworkChangeNotifier : public net::NetworkChangeNotifier {
+class FakeNetworkChangeNotifier : public net::NetworkChangeNotifier {
  public:
-  MOCK_CONST_METHOD0(GetCurrentConnectionType,
-                     net::NetworkChangeNotifier::ConnectionType());
+  FakeNetworkChangeNotifier() : type_(CONNECTION_NONE) {}
+
+  void set_connection_type(ConnectionType type) { type_ = type; }
+
+  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+    return type_;
+  }
+
+ private:
+  net::NetworkChangeNotifier::ConnectionType type_;
 };
 
 void CopyResourceIdFromGetResourceEntryCallback(
     std::vector<std::string>* id_list_out,
     const std::string& requested_id,
     google_apis::GDataErrorCode error_in,
     scoped_ptr<google_apis::ResourceEntry> resource_entry_in) {
   id_list_out->push_back(requested_id);
 }
 
 }  // namespace
 
 class DriveSchedulerTest : public testing::Test {
  public:
   DriveSchedulerTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         profile_(new TestingProfile) {
   }
 
   virtual void SetUp() OVERRIDE {
-    mock_network_change_notifier_.reset(new MockNetworkChangeNotifier);
+    fake_network_change_notifier_.reset(new FakeNetworkChangeNotifier);
 
     fake_drive_service_.reset(new google_apis::FakeDriveService());
     fake_drive_service_->LoadResourceListForWapi(
         "chromeos/gdata/root_feed.json");
     fake_drive_service_->LoadAccountMetadataForWapi(
         "chromeos/gdata/account_metadata.json");
     fake_drive_service_->LoadAppListForDriveApi(
         "chromeos/drive/applist.json");
 
     scheduler_.reset(new DriveScheduler(profile_.get(),
                                         fake_drive_service_.get()));
 
     scheduler_->Initialize();
     scheduler_->SetDisableThrottling(true);
   }
 
   virtual void TearDown() OVERRIDE {
     // The scheduler should be deleted before NetworkLibrary, as it
     // registers itself as observer of NetworkLibrary.
     scheduler_.reset();
     google_apis::test_util::RunBlockingPoolTask();
     fake_drive_service_.reset();
-    mock_network_change_notifier_.reset();
+    fake_network_change_notifier_.reset();
   }
 
-  // Sets up MockNetworkChangeNotifier as if it's connected to a network with
+ protected:
+  // Sets up FakeNetworkChangeNotifier as if it's connected to a network with
   // the specified connection type.
   void ChangeConnectionType(net::NetworkChangeNotifier::ConnectionType type) {
-    EXPECT_CALL(*mock_network_change_notifier_, GetCurrentConnectionType())
-        .WillRepeatedly(Return(type));
+    fake_network_change_notifier_->set_connection_type(type);
     // Notify the sync client that the network is changed. This is done via
     // NetworkChangeNotifier in production, but here, we simulate the behavior
     // by directly calling OnConnectionTypeChanged().
     scheduler_->OnConnectionTypeChanged(type);
   }
 
-  // Sets up MockNetworkChangeNotifier as if it's connected to wifi network.
+  // Sets up FakeNetworkChangeNotifier as if it's connected to wifi network.
   void ConnectToWifi() {
     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_WIFI);
   }
 
-  // Sets up MockNetworkChangeNotifier as if it's connected to cellular network.
+  // Sets up FakeNetworkChangeNotifier as if it's connected to cellular network.
   void ConnectToCellular() {
     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_2G);
   }
 
-  // Sets up MockNetworkChangeNotifier as if it's connected to wimax network.
+  // Sets up FakeNetworkChangeNotifier as if it's connected to wimax network.
   void ConnectToWimax() {
     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_4G);
   }
 
-  // Sets up MockNetworkChangeNotifier as if it's disconnected.
+  // Sets up FakeNetworkChangeNotifier as if it's disconnected.
   void ConnectToNone() {
     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_NONE);
   }
 
- protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<DriveScheduler> scheduler_;
-  scoped_ptr<MockNetworkChangeNotifier> mock_network_change_notifier_;
+  scoped_ptr<FakeNetworkChangeNotifier> fake_network_change_notifier_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
 };
 
 TEST_F(DriveSchedulerTest, GetAboutResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
@@ skipping 590 matching lines @@
 
   // Run the background downloading job as well.
   ConnectToWifi();
   google_apis::test_util::RunBlockingPoolTask();
 
   // All jobs should have finished.
   EXPECT_EQ(0U, scheduler_->GetJobInfoList().size());
 }
 
 }  // namespace drive