Convert Pass()→std::move() in //device

device/bluetooth/bluetooth_adapter_unittest.cc

 // Copyright 2014 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 "device/bluetooth/bluetooth_adapter.h"
+
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
-#include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/test/bluetooth_test.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "device/bluetooth/test/bluetooth_test_android.h"
 #elif defined(OS_MACOSX)
 #include "device/bluetooth/test/bluetooth_test_mac.h"
@@ skipping 31 matching lines @@
   void SetDiscoverable(bool discoverable,
                        const base::Closure& callback,
                        const ErrorCallback& error_callback) override {}
 
   bool IsDiscovering() const override { return false; }
 
   void StartDiscoverySessionWithFilter(
       scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
       const DiscoverySessionCallback& callback,
       const ErrorCallback& error_callback) override {
-    OnStartDiscoverySession(discovery_filter.Pass(), callback);
+    OnStartDiscoverySession(std::move(discovery_filter), callback);
   }
 
   void StartDiscoverySession(const DiscoverySessionCallback& callback,
                              const ErrorCallback& error_callback) override {}
   void CreateRfcommService(
       const BluetoothUUID& uuid,
       const ServiceOptions& options,
       const CreateServiceCallback& callback,
       const CreateServiceErrorCallback& error_callback) override {}
 
@@ skipping 12 matching lines @@
       scoped_ptr<BluetoothAdvertisement::Data> advertisement_data,
       const CreateAdvertisementCallback& callback,
       const CreateAdvertisementErrorCallback& error_callback) override {}
 
   void TestErrorCallback() {}
 
   ScopedVector<BluetoothDiscoverySession> discovery_sessions_;
 
   void TestOnStartDiscoverySession(
       scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
-    discovery_sessions_.push_back(discovery_session.Pass());
+    discovery_sessions_.push_back(std::move(discovery_session));
   }
 
   void CleanupSessions() { discovery_sessions_.clear(); }
 
   void InjectFilteredSession(
       scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter) {
     StartDiscoverySessionWithFilter(
-        discovery_filter.Pass(),
+        std::move(discovery_filter),
         base::Bind(&TestBluetoothAdapter::TestOnStartDiscoverySession,
                    base::Unretained(this)),
         base::Bind(&TestBluetoothAdapter::TestErrorCallback,
                    base::Unretained(this)));
   }
 
  protected:
   ~TestBluetoothAdapter() override {}
 
   void AddDiscoverySession(
@@ skipping 103 matching lines @@
 
   discovery_filter = adapter->GetMergedDiscoveryFilterMasked(nullptr);
   EXPECT_TRUE(discovery_filter.get() == nullptr);
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterRegular) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter;
 
   // make sure adapter have one session wihout filtering.
-  adapter->InjectFilteredSession(discovery_filter.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter));
 
   // having one reglar session should result in no filter
   scoped_ptr<BluetoothDiscoveryFilter> resulting_filter =
       adapter->GetMergedDiscoveryFilter();
   EXPECT_TRUE(resulting_filter.get() == nullptr);
 
   // omiting no filter when having one reglar session should result in no filter
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(nullptr);
   EXPECT_TRUE(resulting_filter.get() == nullptr);
 
@@ skipping 10 matching lines @@
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-30);
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df2->SetRSSI(-65);
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
   // make sure adapter have one session wihout filtering.
-  adapter->InjectFilteredSession(discovery_filter.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter));
 
   // DO_NOTHING should have no impact
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-30, resulting_rssi);
 
   // should not use df2 at all, as it's not associated with adapter yet
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df2);
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-30, resulting_rssi);
 
-  adapter->InjectFilteredSession(discovery_filter2.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter2));
 
   // result of merging two rssi values should be lower one
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-65, resulting_rssi);
 
   // ommit bigger value, result should stay same
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df);
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-65, resulting_rssi);
 
   // ommit lower value, result should change
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df2);
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-30, resulting_rssi);
 
   BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df3->SetPathloss(60);
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // when rssi and pathloss are merged, both should be cleared, becuase there is
   // no way to tell which filter will be more generic
-  adapter->InjectFilteredSession(discovery_filter3.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter3));
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_FALSE(resulting_filter->GetRSSI(&resulting_rssi));
   EXPECT_FALSE(resulting_filter->GetPathloss(&resulting_pathloss));
 
   adapter->CleanupSessions();
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterTransport) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   scoped_ptr<BluetoothDiscoveryFilter> resulting_filter;
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
-  adapter->InjectFilteredSession(discovery_filter.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter));
 
   // Just one filter, make sure transport was properly rewritten
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC,
             resulting_filter->GetTransport());
 
-  adapter->InjectFilteredSession(discovery_filter2.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter2));
 
   // Two filters, should have OR of both transport's
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL,
             resulting_filter->GetTransport());
 
   // When 1st filter is masked, 2nd filter transport should be returned.
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df);
   EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_LE,
             resulting_filter->GetTransport());
 
   // When 2nd filter is masked, 1st filter transport should be returned.
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df2);
   EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC,
             resulting_filter->GetTransport());
 
   BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df3->CopyFrom(BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // Merging empty filter in should result in empty filter
-  adapter->InjectFilteredSession(discovery_filter3.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter3));
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_TRUE(resulting_filter->IsDefault());
 
   adapter->CleanupSessions();
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterAllFields) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   int16_t resulting_rssi;
   std::set<device::BluetoothUUID> resulting_uuids;
@@ skipping 14 matching lines @@
 
   BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df3->SetRSSI(-65);
   df3->SetTransport(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
   df3->AddUUID(device::BluetoothUUID("1020"));
   df3->AddUUID(device::BluetoothUUID("1003"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // make sure adapter have one session wihout filtering.
-  adapter->InjectFilteredSession(discovery_filter.Pass());
-  adapter->InjectFilteredSession(discovery_filter2.Pass());
-  adapter->InjectFilteredSession(discovery_filter3.Pass());
+  adapter->InjectFilteredSession(std::move(discovery_filter));
+  adapter->InjectFilteredSession(std::move(discovery_filter2));
+  adapter->InjectFilteredSession(std::move(discovery_filter3));
 
   scoped_ptr<BluetoothDiscoveryFilter> resulting_filter =
       adapter->GetMergedDiscoveryFilter();
   resulting_filter->GetRSSI(&resulting_rssi);
   resulting_filter->GetUUIDs(resulting_uuids);
   EXPECT_TRUE(resulting_filter->GetTransport());
   EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL,
             resulting_filter->GetTransport());
   EXPECT_EQ(-85, resulting_rssi);
   EXPECT_EQ(4UL, resulting_uuids.size());
@@ skipping 211 matching lines @@
   // Start discovery and find a device.
   StartLowEnergyDiscoverySession();
   DiscoverLowEnergyDevice(1);
   DiscoverLowEnergyDevice(4);
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(2u, adapter_->GetDevices().size());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 }  // namespace device