Removes MessageLoop::TYPE_XXX where possible

device/bluetooth/bluetooth_chromeos_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/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
 #include "chromeos/dbus/fake_bluetooth_input_client.h"
@@ skipping 246 matching lines @@
 
   // Run a discovery phase until the named device is detected, or if the named
   // device is not created, the discovery process ends without finding it.
   //
   // The correct behavior of discovery is tested by the "Discovery" test case
   // without using this function.
   void DiscoverDevice(const std::string& address) {
     ASSERT_TRUE(adapter_.get() != NULL);
 
     if (base::MessageLoop::current() == NULL) {
-      base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+      base::MessageLoop message_loop;
       DiscoverDevices();
       return;
     }
 
     fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
     TestObserver observer(adapter_);
     adapter_->AddObserver(&observer);
 
     adapter_->SetPowered(
@@ skipping 223 matching lines @@
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.powered_changed_count_);
   EXPECT_FALSE(observer.last_powered_);
 
   EXPECT_FALSE(adapter_->IsPowered());
 }
 
 TEST_F(BluetoothChromeOSTest, StopDiscovery) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
 
   GetAdapter();
 
   adapter_->SetPowered(
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   adapter_->StartDiscovering(
@@ skipping 22 matching lines @@
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
 
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, StopDiscoveryAfterTwoStarts) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
 
   GetAdapter();
 
   adapter_->SetPowered(
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   adapter_->StartDiscovering(
@@ skipping 51 matching lines @@
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
 
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, Discovery) {
   // Test a simulated discovery session.
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
 
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   adapter_->SetPowered(
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 26 matching lines @@
   // Okay, let's run forward until a device is actually removed...
   while (!observer.device_removed_count_)
     message_loop.Run();
 
   EXPECT_EQ(1, observer.device_removed_count_);
   EXPECT_EQ(FakeBluetoothDeviceClient::kVanishingDeviceAddress,
             observer.last_device_address_);
 }
 
 TEST_F(BluetoothChromeOSTest, PoweredAndDiscovering) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
 
   GetAdapter();
   adapter_->SetPowered(
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   adapter_->StartDiscovering(
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 478 matching lines @@
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsConnected());
 }
 
 TEST_F(BluetoothChromeOSTest, PairAppleMouse) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Apple Mouse requires no PIN or Passkey to pair; this is equivalent
   // to Simple Secure Pairing or a device with a fixed 0000 PIN.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kAppleMouseAddress);
   ASSERT_TRUE(device != NULL);
@@ skipping 40 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleMousePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairAppleKeyboard) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Apple Keyboard requires that we display a randomly generated
   // PIN on the screen.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kAppleKeyboardAddress);
   ASSERT_TRUE(device != NULL);
@@ skipping 41 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleKeyboardPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairMotorolaKeyboard) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Motorola Keyboard requires that we display a randomly generated
   // Passkey on the screen, and notifies us as it's typed in.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kMotorolaKeyboardAddress);
   ASSERT_TRUE(device != NULL);
@@ skipping 62 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kMotorolaKeyboardPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairSonyHeadphones) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Sony Headphones fake requires that the user enters a PIN for them.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 42 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairPhone) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The fake phone requests that we confirm a displayed passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPhoneAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 39 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairWeirdDevice) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Use the "weird device" fake that requires that the user enters a Passkey,
   // this would be some kind of device that has a display, but doesn't use
   // "just works" - maybe a car?
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kWeirdDeviceAddress);
@@ skipping 40 matching lines @@
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairUnpairableDeviceFails) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnpairableDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
@@ skipping 22 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingFails) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(FakeBluetoothDeviceClient::kVanishingDeviceAddress);
 
   // The vanishing device times out during pairing
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kVanishingDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 23 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingFailsAtConnection) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Everything seems to go according to plan with the unconnectable device;
   // it pairs, but then you can't make connections to it after.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
   ASSERT_TRUE(device != NULL);
@@ skipping 36 matching lines @@
   // Make sure the trusted property has been set to true still (since pairing
   // worked).
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(
               FakeBluetoothDeviceClient::kUnconnectableDevicePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPinCode) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPinCode) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPasskey) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kWeirdDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPasskey) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kWeirdDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtConfirmation) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for passkey confirmation.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPhoneAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtConfirmation) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPhoneAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 26 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledInFlight) {
-  base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop message_loop;
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing while we're waiting for the remote host.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kAppleMouseAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 25 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 }  // namespace chromeos