bluetooth: Refactor bluetooth_adapter.cc for C++ style: dcl/dfn ordering.

device/bluetooth/bluetooth_adapter.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 "device/bluetooth/bluetooth_adapter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 
 namespace device {
 
 BluetoothAdapter::ServiceOptions::ServiceOptions() {
 }
 BluetoothAdapter::ServiceOptions::~ServiceOptions() {
 }
 
 #if !defined(OS_CHROMEOS) && !defined(OS_WIN) && !defined(OS_MACOSX)
 //static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     const InitCallback& init_callback) {
   return base::WeakPtr<BluetoothAdapter>();
 }
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_WIN) && !defined(OS_MACOSX)
 
+base::WeakPtr<BluetoothAdapter> BluetoothAdapter::GetWeakPtrForTesting() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 #if defined(OS_CHROMEOS)
 void BluetoothAdapter::Shutdown() {
   NOTIMPLEMENTED();
 }
 #endif
 
-BluetoothAdapter::BluetoothAdapter()
-    : weak_ptr_factory_(this) {
-}
-
-BluetoothAdapter::~BluetoothAdapter() {
-  STLDeleteValues(&devices_);
-}
-
-base::WeakPtr<BluetoothAdapter> BluetoothAdapter::GetWeakPtrForTesting() {
-  return weak_ptr_factory_.GetWeakPtr();
+void BluetoothAdapter::StartDiscoverySession(
+    const DiscoverySessionCallback& callback,
+    const ErrorCallback& error_callback) {
+  StartDiscoverySessionWithFilter(nullptr, callback, error_callback);
 }
 
 void BluetoothAdapter::StartDiscoverySessionWithFilter(
     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const DiscoverySessionCallback& callback,
     const ErrorCallback& error_callback) {
   AddDiscoverySession(discovery_filter.get(),
                       base::Bind(&BluetoothAdapter::OnStartDiscoverySession,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  base::Passed(&discovery_filter), callback),
                       error_callback);
 }
 
-void BluetoothAdapter::StartDiscoverySession(
-    const DiscoverySessionCallback& callback,
-    const ErrorCallback& error_callback) {
-  StartDiscoverySessionWithFilter(nullptr, callback, error_callback);
-}
-
-scoped_ptr<BluetoothDiscoveryFilter>
-BluetoothAdapter::GetMergedDiscoveryFilterHelper(
-    const BluetoothDiscoveryFilter* masked_filter,
-    bool omit) const {
-  scoped_ptr<BluetoothDiscoveryFilter> result;
-  bool first_merge = true;
-
-  std::set<BluetoothDiscoverySession*> temp(discovery_sessions_);
-  for (const auto& iter : temp) {
-    const BluetoothDiscoveryFilter* curr_filter = iter->GetDiscoveryFilter();
-
-    if (!iter->IsActive())
-      continue;
-
-    if (omit && curr_filter == masked_filter) {
-      // if masked_filter is pointing to empty filter, and there are
-      // multiple empty filters in discovery_sessions_, make sure we'll
-      // process next empty sessions.
-      omit = false;
-      continue;
-    }
-
-    if (first_merge) {
-      first_merge = false;
-      if (curr_filter) {
-        result.reset(new BluetoothDiscoveryFilter(
-            BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL));
-        result->CopyFrom(*curr_filter);
-      }
-      continue;
-    }
-
-    result = BluetoothDiscoveryFilter::Merge(result.get(), curr_filter);
-  }
-
-  return result.Pass();
-}
-
 scoped_ptr<BluetoothDiscoveryFilter>
 BluetoothAdapter::GetMergedDiscoveryFilter() const {
   return GetMergedDiscoveryFilterHelper(nullptr, false);
 }
 
 scoped_ptr<BluetoothDiscoveryFilter>
 BluetoothAdapter::GetMergedDiscoveryFilterMasked(
     BluetoothDiscoveryFilter* masked_filter) const {
   return GetMergedDiscoveryFilterHelper(masked_filter, true);
 }
@@ skipping 66 matching lines @@
   }
 }
 
 BluetoothDevice::PairingDelegate* BluetoothAdapter::DefaultPairingDelegate() {
   if (pairing_delegates_.empty())
     return NULL;
 
   return pairing_delegates_.front().first;
 }
 
+BluetoothAdapter::BluetoothAdapter() : weak_ptr_factory_(this) {
+}
+
+BluetoothAdapter::~BluetoothAdapter() {
+  STLDeleteValues(&devices_);
+}
+
 void BluetoothAdapter::OnStartDiscoverySession(
     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const DiscoverySessionCallback& callback) {
   VLOG(1) << "Discovery session started!";
   scoped_ptr<BluetoothDiscoverySession> discovery_session(
       new BluetoothDiscoverySession(scoped_refptr<BluetoothAdapter>(this),
                                     discovery_filter.Pass()));
   discovery_sessions_.insert(discovery_session.get());
   callback.Run(discovery_session.Pass());
 }
@@ skipping 10 matching lines @@
     (*iter)->MarkAsInactive();
   }
 }
 
 void BluetoothAdapter::DiscoverySessionBecameInactive(
     BluetoothDiscoverySession* discovery_session) {
   DCHECK(!discovery_session->IsActive());
   discovery_sessions_.erase(discovery_session);
 }
 
+scoped_ptr<BluetoothDiscoveryFilter>
+BluetoothAdapter::GetMergedDiscoveryFilterHelper(
+    const BluetoothDiscoveryFilter* masked_filter,
+    bool omit) const {
+  scoped_ptr<BluetoothDiscoveryFilter> result;
+  bool first_merge = true;
+
+  std::set<BluetoothDiscoverySession*> temp(discovery_sessions_);
+  for (const auto& iter : temp) {
+    const BluetoothDiscoveryFilter* curr_filter = iter->GetDiscoveryFilter();
+
+    if (!iter->IsActive())
+      continue;
+
+    if (omit && curr_filter == masked_filter) {
+      // if masked_filter is pointing to empty filter, and there are
+      // multiple empty filters in discovery_sessions_, make sure we'll
+      // process next empty sessions.
+      omit = false;
+      continue;
+    }
+
+    if (first_merge) {
+      first_merge = false;
+      if (curr_filter) {
+        result.reset(new BluetoothDiscoveryFilter(
+            BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL));
+        result->CopyFrom(*curr_filter);
+      }
+      continue;
+    }
+
+    result = BluetoothDiscoveryFilter::Merge(result.get(), curr_filter);
+  }
+
+  return result.Pass();
+}
+
 }  // namespace device