Delayed adding BluetoothEventRouter as BluetoothAdapter observer until when the

chrome/browser/extensions/api/bluetooth/bluetooth_apitest.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 <string.h>
 
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 #include "chrome/browser/extensions/bluetooth_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
@@ skipping 170 matching lines @@
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetName) {
   scoped_refptr<api::BluetoothGetNameFunction> get_name;
   get_name = setupFunction(new api::BluetoothGetNameFunction);
   expectStringResult(kName, get_name);
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetLocalOutOfBandPairingData) {
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallOutOfBandPairingDataCallback));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
 
   scoped_refptr<api::BluetoothGetLocalOutOfBandPairingDataFunction>
       get_oob_function(setupFunction(
             new api::BluetoothGetLocalOutOfBandPairingDataFunction));
 
   scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
       get_oob_function, "[]", browser()));
 
   base::DictionaryValue* dict;
   EXPECT_TRUE(result->GetAsDictionary(&dict));
 
   base::BinaryValue* binary_value;
   EXPECT_TRUE(dict->GetBinary("hash", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataHash,
       std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
   EXPECT_TRUE(dict->GetBinary("randomizer", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataRandomizer,
       std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
 
   // Try again with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(
                   testing::_,
                   testing::Truly(CallClosure)));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
 
   get_oob_function =
       setupFunction(new api::BluetoothGetLocalOutOfBandPairingDataFunction);
 
   std::string error(
       utils::RunFunctionAndReturnError(get_oob_function, "[]", browser()));
   EXPECT_FALSE(error.empty());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, SetOutOfBandPairingData) {
   std::string device_address("11:12:13:14:15:16");
   EXPECT_CALL(*mock_adapter_, GetDevice(device_address))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ClearOutOfBandPairingData(testing::Truly(CallClosure),
                                         testing::_));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
 
   std::string params = base::StringPrintf(
       "[{\"deviceAddress\":\"%s\"}]", device_address.c_str());
 
   scoped_refptr<api::BluetoothSetOutOfBandPairingDataFunction> set_oob_function;
   set_oob_function = setupFunction(
       new api::BluetoothSetOutOfBandPairingDataFunction);
   // There isn't actually a result.
   (void)utils::RunFunctionAndReturnSingleResult(
       set_oob_function, params, browser());
 
   // Try again with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   testing::Mock::VerifyAndClearExpectations(device1_.get());
   EXPECT_CALL(*mock_adapter_, GetDevice(device_address))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ClearOutOfBandPairingData(testing::_,
                                         testing::Truly(CallClosure)));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
 
   set_oob_function = setupFunction(
       new api::BluetoothSetOutOfBandPairingDataFunction);
   std::string error(
       utils::RunFunctionAndReturnError(set_oob_function, params, browser()));
   EXPECT_FALSE(error.empty());
 
   // TODO(bryeung): Also test setting the data when there is support for
   // ArrayBuffers in the arguments to the RunFunctionAnd* methods.
   // crbug.com/132796
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
   // Try with a failure to start
   EXPECT_CALL(*mock_adapter_, IsDiscovering()).WillOnce(testing::Return(false));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(true,
                              testing::_,
                              testing::Truly(CallClosure)));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
   scoped_refptr<api::BluetoothStartDiscoveryFunction> start_function;
   start_function = setupFunction(new api::BluetoothStartDiscoveryFunction);
   std::string error(
       utils::RunFunctionAndReturnError(start_function, "[]", browser()));
   ASSERT_TRUE(!error.empty());
 
   // Reset for a successful start
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_, IsDiscovering()).WillOnce(testing::Return(false));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(true,
                              testing::Truly(CallClosure),
                              testing::_));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
 
   start_function = setupFunction(new api::BluetoothStartDiscoveryFunction);
   (void)utils::RunFunctionAndReturnError(start_function, "[]", browser());
 
   // Reset to try stopping
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false,
                              testing::Truly(CallClosure),
                              testing::_));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
   scoped_refptr<api::BluetoothStopDiscoveryFunction> stop_function;
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
   (void)utils::RunFunctionAndReturnSingleResult(stop_function, "[]", browser());
 
   // Reset to try stopping with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false,
                              testing::_,
                              testing::Truly(CallClosure)));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .WillOnce(testing::Return());
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
   error = utils::RunFunctionAndReturnError(stop_function, "[]", browser());
   ASSERT_TRUE(!error.empty());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DiscoveryCallback) {
   EXPECT_CALL(*mock_adapter_, IsDiscovering()).WillOnce(testing::Return(false));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(true, testing::Truly(CallClosure), testing::_));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false, testing::Truly(CallClosure), testing::_));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .Times(testing::AtLeast(1))
+      .WillRepeatedly(testing::Return());
 
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   ExtensionTestMessageListener discovery_started("ready", true);
   ASSERT_TRUE(LoadExtension(
         test_data_dir_.AppendASCII("bluetooth/discovery_callback")));
   EXPECT_TRUE(discovery_started.WaitUntilSatisfied());
 
   event_router()->DeviceAdded(mock_adapter_, device1_.get());
@@ skipping 39 matching lines @@
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Events) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .Times(testing::AtLeast(1))
+      .WillRepeatedly(testing::Return());
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("bluetooth/events")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   event_router()->AdapterPoweredChanged(mock_adapter_, true);
   event_router()->AdapterPoweredChanged(mock_adapter_, false);
   event_router()->AdapterPresentChanged(mock_adapter_, true);
   event_router()->AdapterPresentChanged(mock_adapter_, false);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, true);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, false);
 
@@ skipping 17 matching lines @@
       .WillOnce(testing::Invoke(CallProvidesServiceCallback<true>));
 
   EXPECT_CALL(*device2_, ProvidesServiceWithUUID(testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*device2_, ProvidesServiceWithName(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallProvidesServiceCallback<false>));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .Times(3)
       .WillRepeatedly(testing::Return(devices));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .Times(testing::AtLeast(1))
+      .WillRepeatedly(testing::Return());
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
   ASSERT_TRUE(
       LoadExtension(test_data_dir_.AppendASCII("bluetooth/get_devices")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetDevicesConcurrently) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   BluetoothAdapter::ConstDeviceList devices;
   devices.push_back(device1_.get());
 
   // Save the callback to delay execution so that we can force the calls to
   // happen concurrently.  This will be called after the listener is satisfied.
   BluetoothDevice::ProvidesServiceCallback* callback =
       new BluetoothDevice::ProvidesServiceCallback;
   EXPECT_CALL(*device1_, ProvidesServiceWithName(testing::_, testing::_))
       .WillOnce(testing::SaveArg<1>(callback));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .WillOnce(testing::Return(devices));
+  EXPECT_CALL(*mock_adapter_, AddObserver(testing::_))
+      .Times(testing::AtLeast(1))
+      .WillRepeatedly(testing::Return());
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
   ASSERT_TRUE(LoadExtension(
         test_data_dir_.AppendASCII("bluetooth/get_devices_concurrently")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   callback->Run(false);
   delete callback;
   listener.Reply("go");
@@ skipping 10 matching lines @@
   ExtensionTestMessageListener listener("ready", true);
   ASSERT_TRUE(LoadExtension(
         test_data_dir_.AppendASCII("bluetooth/get_devices_error")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   CloseShellWindowsAndWaitForAppToExit();
 }