Migrate Chrome OS Bluetooth UI to the new discovery API.

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 228 matching lines @@
 
     fake_bluetooth_adapter_client_->SetSimulationIntervalMs(10);
 
     callback_count_ = 0;
     error_callback_count_ = 0;
     last_connect_error_ = BluetoothDevice::ERROR_UNKNOWN;
     last_client_error_ = "";
   }
 
   virtual void TearDown() {
-    if (last_discovery_session_.get() && last_discovery_session_->active()) {
+    if (last_discovery_session_.get() && last_discovery_session_->IsActive()) {
       callback_count_ = 0;
       last_discovery_session_->Stop(
           base::Bind(&BluetoothChromeOSTest::Callback,
                      base::Unretained(this)),
           base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                      base::Unretained(this)));
       message_loop_.Run();
       ASSERT_EQ(1, callback_count_);
     }
     last_discovery_session_.reset();
@@ skipping 1056 matching lines @@
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(last_discovery_session_.get());
-  EXPECT_TRUE(last_discovery_session_->active());
+  EXPECT_TRUE(last_discovery_session_->IsActive());
 
   // Start another session. A new one should be returned in the callback, which
   // in turn will destroy the previous session. Adapter should still be
   // discovering and the reference count should be 1.
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(last_discovery_session_.get());
-  EXPECT_TRUE(last_discovery_session_->active());
+  EXPECT_TRUE(last_discovery_session_->IsActive());
 
   // Hold on to the current discovery session to prevent it from getting
   // destroyed during the next call to StartDiscoverySession.
   scoped_ptr<BluetoothDiscoverySession> discovery_session =
       last_discovery_session_.Pass();
 
   // Request a new session.
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(last_discovery_session_.get());
-  EXPECT_TRUE(last_discovery_session_->active());
+  EXPECT_TRUE(last_discovery_session_->IsActive());
   EXPECT_NE(last_discovery_session_.get(), discovery_session);
 
   // Stop the previous discovery session. The session should end but discovery
   // should continue.
   discovery_session->Stop(
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(last_discovery_session_.get());
-  EXPECT_TRUE(last_discovery_session_->active());
-  EXPECT_FALSE(discovery_session->active());
+  EXPECT_TRUE(last_discovery_session_->IsActive());
+  EXPECT_FALSE(discovery_session->IsActive());
 
   // Delete the current active session. Discovery should eventually stop.
   last_discovery_session_.reset();
   while (observer.last_discovering_) {
     message_loop_.RunUntilIdle();
   }
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
@@ skipping 1696 matching lines @@
   device->SetPasskey(1234);
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsPaired());
 }
 
 }  // namespace chromeos