diff --git a/drivers/bluetooth/lib/data/domain.cc b/drivers/bluetooth/lib/data/domain.cc
index 03bf059..0f2387b 100644
--- a/drivers/bluetooth/lib/data/domain.cc
+++ b/drivers/bluetooth/lib/data/domain.cc
@@ -65,17 +65,13 @@
   void AddACLConnection(hci::ConnectionHandle handle,
                         hci::Connection::Role role,
                         l2cap::LinkErrorCallback link_error_callback,
+                        l2cap::SecurityUpgradeCallback security_callback,
                         async_dispatcher_t* dispatcher) override {
     PostMessage([this, handle, role, lec = std::move(link_error_callback),
-                 dispatcher]() mutable {
+                 suc = std::move(security_callback), dispatcher]() mutable {
       if (l2cap_) {
-        // TODO(NET-1151): Pass security upgrade callback from an argument.
-        l2cap_->RegisterACL(
-            handle, role, std::move(lec),
-            [](auto, auto, auto) {
-              bt_log(TRACE, "data-domain", "not implemented: L2CAP security");
-            },
-            dispatcher);
+        l2cap_->RegisterACL(handle, role, std::move(lec), std::move(suc),
+                            dispatcher);
       }
     });
   }
@@ -83,27 +79,24 @@
   void AddLEConnection(
       hci::ConnectionHandle handle, hci::Connection::Role role,
       l2cap::LinkErrorCallback link_error_callback,
-      l2cap::LEFixedChannelsCallback channel_callback,
       l2cap::LEConnectionParameterUpdateCallback conn_param_callback,
+      l2cap::LEFixedChannelsCallback channel_callback,
+      l2cap::SecurityUpgradeCallback security_callback,
       async_dispatcher_t* dispatcher) override {
-    PostMessage([this, handle, role, cp_cb = std::move(conn_param_callback),
-                 link_err_cb = std::move(link_error_callback),
-                 chan_cb = std::move(channel_callback), dispatcher]() mutable {
+    PostMessage([this, handle, role, cpc = std::move(conn_param_callback),
+                 lec = std::move(link_error_callback),
+                 suc = std::move(security_callback),
+                 cc = std::move(channel_callback), dispatcher]() mutable {
       if (l2cap_) {
-        // TODO(NET-1151): Pass security upgrade callback from an argument.
-        l2cap_->RegisterLE(
-            handle, role, std::move(cp_cb), std::move(link_err_cb),
-            [](auto, auto, auto) {
-              bt_log(TRACE, "data-domain", "not implemented: L2CAP security");
-            },
-            dispatcher);
+        l2cap_->RegisterLE(handle, role, std::move(cpc), std::move(lec),
+                           std::move(suc), dispatcher);
 
         auto att = l2cap_->OpenFixedChannel(handle, l2cap::kATTChannelId);
         auto smp = l2cap_->OpenFixedChannel(handle, l2cap::kLESMPChannelId);
         ZX_DEBUG_ASSERT(att);
         ZX_DEBUG_ASSERT(smp);
         async::PostTask(dispatcher, [att = std::move(att), smp = std::move(smp),
-                                     cb = std::move(chan_cb)]() mutable {
+                                     cb = std::move(cc)]() mutable {
           cb(std::move(att), std::move(smp));
         });
       }
@@ -118,6 +111,15 @@
     });
   }
 
+  void AssignLinkSecurityProperties(hci::ConnectionHandle handle,
+                                    sm::SecurityProperties security) override {
+    PostMessage([this, handle, security] {
+      if (l2cap_) {
+        l2cap_->AssignLinkSecurityProperties(handle, security);
+      }
+    });
+  }
+
   void OpenL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm,
                         l2cap::ChannelCallback cb,
                         async_dispatcher_t* dispatcher) override {
diff --git a/drivers/bluetooth/lib/data/domain.h b/drivers/bluetooth/lib/data/domain.h
index 1df4d8f..5ebcad8 100644
--- a/drivers/bluetooth/lib/data/domain.h
+++ b/drivers/bluetooth/lib/data/domain.h
@@ -52,11 +52,16 @@
   // |link_error_callback| will be used to notify when a channel signals a link
   // error. It will be posted onto |dispatcher|.
   //
+  // |security_callback| will be used to request an upgrade to the link security
+  // level. This can be triggered by dynamic L2CAP channel creation or by a
+  // service-level client via Channel::UpgradeSecurity().
+  //
   // Has no effect if this Domain is uninitialized or shut down.
-  virtual void AddACLConnection(hci::ConnectionHandle handle,
-                                hci::Connection::Role role,
-                                l2cap::LinkErrorCallback link_error_callback,
-                                async_dispatcher_t* dispatcher) = 0;
+  virtual void AddACLConnection(
+      hci::ConnectionHandle handle, hci::Connection::Role role,
+      l2cap::LinkErrorCallback link_error_callback,
+      l2cap::SecurityUpgradeCallback security_callback,
+      async_dispatcher_t* dispatcher) = 0;
 
   // Registers an LE connection with the L2CAP layer. L2CAP channels can be
   // opened on the logical link represented by |handle| after a call to this
@@ -68,6 +73,10 @@
   // |link_error_callback| will be used to notify when a channel signals a link
   // error.
   //
+  // |security_callback| will be used to request an upgrade to the link security
+  // level. This can be triggered by dynamic L2CAP channel creation or by a
+  // service-level client via Channel::UpgradeSecurity().
+  //
   // Upon successful registration of the link, |channel_callback| will be called
   // with the ATT and SMP fixed channels.
   //
@@ -75,8 +84,9 @@
   virtual void AddLEConnection(
       hci::ConnectionHandle handle, hci::Connection::Role role,
       l2cap::LinkErrorCallback link_error_callback,
-      l2cap::LEFixedChannelsCallback channel_callback,
       l2cap::LEConnectionParameterUpdateCallback conn_param_callback,
+      l2cap::LEFixedChannelsCallback channel_callback,
+      l2cap::SecurityUpgradeCallback security_callback,
       async_dispatcher_t* dispatcher) = 0;
 
   // Removes a previously registered connection. All corresponding Channels will
@@ -90,6 +100,11 @@
   // Has no effect if this Domain is uninitialized or shut down.
   virtual void RemoveConnection(hci::ConnectionHandle handle) = 0;
 
+  // Assigns the security level of a logical link. Has no effect if |handle| has
+  // not been previously registered or the link is closed.
+  virtual void AssignLinkSecurityProperties(
+      hci::ConnectionHandle handle, sm::SecurityProperties security) = 0;
+
   // Open an outbound dynamic channel against a peer's Protocol/Service
   // Multiplexing (PSM) code |psm| on a link identified by |handle|.
   //
diff --git a/drivers/bluetooth/lib/data/domain_unittest.cc b/drivers/bluetooth/lib/data/domain_unittest.cc
index 153e7d0..6c9f3b1 100644
--- a/drivers/bluetooth/lib/data/domain_unittest.cc
+++ b/drivers/bluetooth/lib/data/domain_unittest.cc
@@ -198,7 +198,8 @@
 
   // Register a fake link.
   domain()->AddACLConnection(
-      kLinkHandle, hci::Connection::Role::kMaster, [] {}, dispatcher());
+      kLinkHandle, hci::Connection::Role::kMaster, [] {},
+      [](auto, auto, auto) {}, dispatcher());
 
   zx::socket sock;
   ASSERT_FALSE(sock);
@@ -244,7 +245,8 @@
 
   // Register a fake link.
   domain()->AddACLConnection(
-      kLinkHandle, hci::Connection::Role::kMaster, [] {}, dispatcher());
+      kLinkHandle, hci::Connection::Role::kMaster, [] {},
+      [](auto, auto, auto) {}, dispatcher());
 
   zx::socket sock;
   ASSERT_FALSE(sock);
diff --git a/drivers/bluetooth/lib/data/fake_domain.cc b/drivers/bluetooth/lib/data/fake_domain.cc
index 4b3d197..94e4879 100644
--- a/drivers/bluetooth/lib/data/fake_domain.cc
+++ b/drivers/bluetooth/lib/data/fake_domain.cc
@@ -87,6 +87,7 @@
 void FakeDomain::AddACLConnection(hci::ConnectionHandle handle,
                                   hci::Connection::Role role,
                                   l2cap::LinkErrorCallback link_error_cb,
+                                  l2cap::SecurityUpgradeCallback security_cb,
                                   async_dispatcher_t* dispatcher) {
   if (!initialized_)
     return;
@@ -98,8 +99,9 @@
 void FakeDomain::AddLEConnection(
     hci::ConnectionHandle handle, hci::Connection::Role role,
     l2cap::LinkErrorCallback link_error_cb,
-    l2cap::LEFixedChannelsCallback channel_cb,
     l2cap::LEConnectionParameterUpdateCallback conn_param_cb,
+    l2cap::LEFixedChannelsCallback channel_cb,
+    l2cap::SecurityUpgradeCallback security_cb,
     async_dispatcher_t* dispatcher) {
   if (!initialized_)
     return;
@@ -122,6 +124,11 @@
   links_.erase(handle);
 }
 
+void FakeDomain::AssignLinkSecurityProperties(hci::ConnectionHandle handle,
+                                              sm::SecurityProperties security) {
+  // TODO(armansito): implement
+}
+
 void FakeDomain::OpenL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm,
                                   l2cap::ChannelCallback cb,
                                   async_dispatcher_t* dispatcher) {
diff --git a/drivers/bluetooth/lib/data/fake_domain.h b/drivers/bluetooth/lib/data/fake_domain.h
index 7e0db30..7a770f0 100644
--- a/drivers/bluetooth/lib/data/fake_domain.h
+++ b/drivers/bluetooth/lib/data/fake_domain.h
@@ -54,14 +54,18 @@
   void AddACLConnection(hci::ConnectionHandle handle,
                         hci::Connection::Role role,
                         l2cap::LinkErrorCallback link_error_callback,
+                        l2cap::SecurityUpgradeCallback security_callback,
                         async_dispatcher_t* dispatcher) override;
   void AddLEConnection(
       hci::ConnectionHandle handle, hci::Connection::Role role,
       l2cap::LinkErrorCallback link_error_callback,
-      l2cap::LEFixedChannelsCallback channel_callback,
       l2cap::LEConnectionParameterUpdateCallback conn_param_callback,
+      l2cap::LEFixedChannelsCallback channel_callback,
+      l2cap::SecurityUpgradeCallback security_callback,
       async_dispatcher_t* dispatcher) override;
   void RemoveConnection(hci::ConnectionHandle handle) override;
+  void AssignLinkSecurityProperties(hci::ConnectionHandle handle,
+                                    sm::SecurityProperties security) override;
   void OpenL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm,
                         l2cap::ChannelCallback cb,
                         async_dispatcher_t* dispatcher) override;
diff --git a/drivers/bluetooth/lib/gap/bredr_connection_manager.cc b/drivers/bluetooth/lib/gap/bredr_connection_manager.cc
index 61c5ebd..1ad3019 100644
--- a/drivers/bluetooth/lib/gap/bredr_connection_manager.cc
+++ b/drivers/bluetooth/lib/gap/bredr_connection_manager.cc
@@ -16,6 +16,8 @@
 namespace btlib {
 namespace gap {
 
+using common::HostError;
+
 namespace {
 
 void SetPageScanEnabled(bool enabled, fxl::RefPtr<hci::Transport> hci,
@@ -327,6 +329,14 @@
           return;
         }
 
+        // TODO(armansito): Implement this callback.
+        auto security_callback = [](hci::ConnectionHandle handle,
+                                    sm::SecurityLevel level, auto cb) {
+          bt_log(INFO, "gap-bredr",
+                 "Ignoring security upgrade request; not implemented");
+          cb(sm::Status(HostError::kNotSupported));
+        };
+
         // Register with L2CAP to handle services on the ACL signaling channel.
         self->data_domain_->AddACLConnection(
             conn_ptr->handle(), conn_ptr->role(),
@@ -343,7 +353,7 @@
               // TODO(NET-1442): Test link error behavior using FakeDevice.
               conn_ptr->Close();
             },
-            self->dispatcher_);
+            std::move(security_callback), self->dispatcher_);
 
         self->connections_.emplace(conn_ptr->handle(), std::move(conn_ptr));
         device->MutBrEdr().SetConnectionState(
diff --git a/drivers/bluetooth/lib/gap/low_energy_connection_manager.cc b/drivers/bluetooth/lib/gap/low_energy_connection_manager.cc
index e2ec298..1dab1ce 100644
--- a/drivers/bluetooth/lib/gap/low_energy_connection_manager.cc
+++ b/drivers/bluetooth/lib/gap/low_energy_connection_manager.cc
@@ -37,19 +37,30 @@
   LowEnergyConnection(const std::string& id,
                       std::unique_ptr<hci::Connection> link,
                       async_dispatcher_t* dispatcher,
-                      fxl::WeakPtr<LowEnergyConnectionManager> conn_mgr)
+                      fxl::WeakPtr<LowEnergyConnectionManager> conn_mgr,
+                      fbl::RefPtr<data::Domain> data_domain,
+                      fbl::RefPtr<gatt::GATT> gatt)
       : id_(id),
         link_(std::move(link)),
         dispatcher_(dispatcher),
         conn_mgr_(conn_mgr),
+        data_domain_(data_domain),
+        gatt_(gatt),
         weak_ptr_factory_(this) {
     ZX_DEBUG_ASSERT(!id_.empty());
     ZX_DEBUG_ASSERT(link_);
     ZX_DEBUG_ASSERT(dispatcher_);
     ZX_DEBUG_ASSERT(conn_mgr_);
+    ZX_DEBUG_ASSERT(data_domain_);
+    ZX_DEBUG_ASSERT(gatt_);
   }
 
   ~LowEnergyConnection() override {
+    // Unregister this link from the GATT profile and the L2CAP plane. This
+    // invalidates all L2CAP channels that are associated with this link.
+    gatt_->RemoveConnection(id());
+    data_domain_->RemoveConnection(link_->handle());
+
     // Tell the controller to disconnect the link if it is marked as open.
     link_->Close();
 
@@ -83,63 +94,23 @@
 
   // Registers this connection with L2CAP and initializes the fixed channel
   // protocols.
-  void InitializeFixedChannels(fbl::RefPtr<data::Domain> data_domain,
-                               fbl::RefPtr<gatt::GATT> gatt,
-                               l2cap::LEConnectionParameterUpdateCallback cp_cb,
+  void InitializeFixedChannels(l2cap::LEConnectionParameterUpdateCallback cp_cb,
                                l2cap::LinkErrorCallback link_error_cb) {
     auto self = weak_ptr_factory_.GetWeakPtr();
-    auto channels_cb = [self, gatt](fbl::RefPtr<l2cap::Channel> att,
-                                    fbl::RefPtr<l2cap::Channel> smp) {
-      if (!self || !att || !smp) {
-        bt_log(TRACE, "gap-le",
-               "link was closed before opening fixed channels");
-        return;
-      }
-
-      // Obtain existing pairing data, if any.
-      std::optional<sm::LTK> ltk;
-      auto* dev = self->conn_mgr_->device_cache()->FindDeviceById(self->id_);
-      ZX_DEBUG_ASSERT_MSG(dev, "connected device must be present in cache!");
-
-      if (dev->le() && dev->le()->bond_data() && dev->le()->bond_data()->ltk) {
-        ltk = *dev->le()->bond_data()->ltk;
-      }
-
-      // Obtain the local I/O capabilities from the delegate. Default to
-      // NoInputNoOutput if no delegate is available.
-      auto io_cap = sm::IOCapability::kNoInputNoOutput;
-      if (self->conn_mgr_->pairing_delegate()) {
-        io_cap = self->conn_mgr_->pairing_delegate()->io_capability();
-      }
-      auto pairing = std::make_unique<sm::PairingState>(
-          self->link_->WeakPtr(), std::move(smp), io_cap, self);
-
-      // TODO(NET-1151): We register the connection with GATT but don't perform
-      // service discovery until after pairing has completed. Fix this so that
-      // services are discovered immediately and pairing happens in response to
-      // a service request unless the peer is already paired.
-      gatt->AddConnection(self->id(), std::move(att));
-
-      if (ltk) {
-        bt_log(INFO, "gap-le", "encrypting link with existing LTK");
-        pairing->SetCurrentSecurity(*ltk);
-        gatt->DiscoverServices(self->id_);
-      } else {
-        bt_log(INFO, "gap-le", "pairing with device");
-        pairing->UpgradeSecurity(
-            sm::SecurityLevel::kEncrypted,
-            [gatt, id = self->id()](sm::Status status, const auto& props) {
-              bt_log(INFO, "gap-le", "pairing status: %s, properties: %s",
-                     status.ToString().c_str(), props.ToString().c_str());
-              gatt->DiscoverServices(id);
-            });
-      }
-      self->pairing_ = std::move(pairing);
-    };
-
-    data_domain->AddLEConnection(
+    data_domain_->AddLEConnection(
         link_->handle(), link_->role(), std::move(link_error_cb),
-        std::move(channels_cb), std::move(cp_cb), dispatcher_);
+        std::move(cp_cb),
+        [self](auto att, auto smp) {
+          if (self) {
+            self->OnL2capFixedChannelsOpened(std::move(att), std::move(smp));
+          }
+        },
+        [self](auto handle, auto level, auto cb) {
+          if (self) {
+            self->OnSecurityUpgradeRequest(handle, level, std::move(cb));
+          }
+        },
+        dispatcher_);
   }
 
   // Cancels any on-going pairing procedures and sets up SMP to use the provided
@@ -153,6 +124,68 @@
   hci::Connection* link() const { return link_.get(); }
 
  private:
+  // Called by the L2CAP layer once the link has been registered and the fixed
+  // channels have been opened.
+  void OnL2capFixedChannelsOpened(fbl::RefPtr<l2cap::Channel> att,
+                                  fbl::RefPtr<l2cap::Channel> smp) {
+    if (!att || !smp) {
+      bt_log(TRACE, "gap-le", "link was closed before opening fixed channels");
+      return;
+    }
+
+    bt_log(TRACE, "gap-le", "ATT and SMP fixed channels open");
+
+    // Obtain existing pairing data, if any.
+    std::optional<sm::LTK> ltk;
+    auto* dev = conn_mgr_->device_cache()->FindDeviceById(id());
+    ZX_DEBUG_ASSERT_MSG(dev, "connected device must be present in cache!");
+
+    if (dev->le() && dev->le()->bond_data()) {
+      // |ltk| will remain as std::nullopt if bonding data contains no LTK.
+      ltk = dev->le()->bond_data()->ltk;
+    }
+
+    // Obtain the local I/O capabilities from the delegate. Default to
+    // NoInputNoOutput if no delegate is available.
+    auto io_cap = sm::IOCapability::kNoInputNoOutput;
+    if (conn_mgr_->pairing_delegate()) {
+      io_cap = conn_mgr_->pairing_delegate()->io_capability();
+    }
+
+    pairing_ = std::make_unique<sm::PairingState>(
+        link_->WeakPtr(), std::move(smp), io_cap,
+        weak_ptr_factory_.GetWeakPtr());
+
+    // Encrypt the link with the current LTK if it exists.
+    if (ltk) {
+      bt_log(INFO, "gap-le", "encrypting link with existing LTK");
+      pairing_->SetCurrentSecurity(*ltk);
+    }
+
+    // Initialize the GATT layer.
+    gatt_->AddConnection(id(), std::move(att));
+    gatt_->DiscoverServices(id());
+  }
+
+  // Handles a security upgrade request received from the L2CAP layer.
+  void OnSecurityUpgradeRequest(hci::ConnectionHandle handle,
+                                sm::SecurityLevel level,
+                                sm::StatusCallback callback) {
+    ZX_DEBUG_ASSERT(link_->handle() == handle);
+    ZX_DEBUG_ASSERT(pairing_);
+
+    bt_log(TRACE, "gap-le", "received security upgrade request");
+
+    pairing_->UpgradeSecurity(
+        level, [handle, dd = data_domain_, cb = std::move(callback)](
+                   sm::Status status, const auto& sp) {
+          bt_log(INFO, "gap-le", "pairing status: %s, properties: %s",
+                 status.ToString().c_str(), sp.ToString().c_str());
+          dd->AssignLinkSecurityProperties(handle, sp);
+          cb(status);
+        });
+  }
+
   // sm::PairingState::Delegate override:
   void OnNewPairingData(const sm::PairingData& pairing_data) override {
     // Consider the pairing temporary if no link key was received. This
@@ -176,6 +209,11 @@
                : "",
            pairing_data.csrk ? "csrk " : "", id().c_str());
 
+    // Update the data plane with the correct link security level.
+    ZX_DEBUG_ASSERT(pairing_);
+    data_domain_->AssignLinkSecurityProperties(link_->handle(),
+                                               pairing_->security());
+
     if (!conn_mgr_->device_cache()->StoreLowEnergyBond(id_, pairing_data)) {
       bt_log(ERROR, "gap-le", "failed to cache bonding data (id: %s)",
              id().c_str());
@@ -185,6 +223,7 @@
   // sm::PairingState::Delegate override:
   void OnPairingComplete(sm::Status status) override {
     bt_log(TRACE, "gap-le", "pairing complete: %s", status.ToString().c_str());
+
     auto delegate = conn_mgr_->pairing_delegate();
     if (delegate) {
       delegate->CompletePairing(id_, status);
@@ -197,6 +236,13 @@
     // stored link key is not valid.
     bt_log(ERROR, "gap-le", "link layer authentication failed: %s",
            status.ToString().c_str());
+
+    // Report the link to be non-secure.
+    // TODO(armansito): sm::PairingState::security() should accurately reflect
+    // the link security properties. It can currently contain a stale value
+    // following authentication failures.
+    data_domain_->AssignLinkSecurityProperties(link_->handle(),
+                                               sm::SecurityProperties());
   }
 
   // sm::PairingState::Delegate override:
@@ -263,6 +309,14 @@
   async_dispatcher_t* dispatcher_;
   fxl::WeakPtr<LowEnergyConnectionManager> conn_mgr_;
 
+  // Reference to the data plane is used to update the L2CAP layer to
+  // reflect the correct link security level.
+  fbl::RefPtr<data::Domain> data_domain_;
+
+  // Reference to the GATT profile layer is used to initiate service discovery
+  // and register the link.
+  fbl::RefPtr<gatt::GATT> gatt_;
+
   // SMP pairing manager.
   std::unique_ptr<sm::PairingState> pairing_;
 
@@ -646,9 +700,9 @@
 
   // Initialize connection.
   auto conn = std::make_unique<internal::LowEnergyConnection>(
-      device_id, std::move(link), dispatcher_, weak_ptr_factory_.GetWeakPtr());
-  conn->InitializeFixedChannels(data_domain_, gatt_,
-                                std::move(conn_param_update_cb),
+      device_id, std::move(link), dispatcher_, weak_ptr_factory_.GetWeakPtr(),
+      data_domain_, gatt_);
+  conn->InitializeFixedChannels(std::move(conn_param_update_cb),
                                 std::move(link_error_cb));
 
   auto first_ref = conn->AddRef();
@@ -687,13 +741,6 @@
   peer->MutLe().SetConnectionState(
       RemoteDevice::ConnectionState::kNotConnected);
 
-  // Clean up GATT profile.
-  gatt_->RemoveConnection(conn->id());
-
-  // Remove the connection from L2CAP. This will invalidate all channels that
-  // are associated with this link.
-  data_domain_->RemoveConnection(conn->handle());
-
   if (!close_link) {
     // Mark the connection as already closed so that hci::Connection::Close()
     // doesn't send HCI_Disconnect to the controller.
diff --git a/drivers/bluetooth/lib/sdp/server_unittest.cc b/drivers/bluetooth/lib/sdp/server_unittest.cc
index 1b7f545..fe99160 100644
--- a/drivers/bluetooth/lib/sdp/server_unittest.cc
+++ b/drivers/bluetooth/lib/sdp/server_unittest.cc
@@ -44,9 +44,9 @@
         [this](auto fake_chan) { channel_ = std::move(fake_chan); });
     l2cap_->Initialize();
     l2cap_->AddACLConnection(kTestHandle1, hci::Connection::Role::kSlave,
-                             nullptr, nullptr);
+                             nullptr, nullptr, nullptr);
     l2cap_->AddACLConnection(kTestHandle2, hci::Connection::Role::kSlave,
-                             nullptr, nullptr);
+                             nullptr, nullptr, nullptr);
     server_ = std::make_unique<Server>(l2cap_);
   }
 
@@ -834,7 +834,8 @@
   ASSERT_EQ(DataElement::Type::kSequence, group_attr_it->second.type());
   ASSERT_EQ(DataElement::Type::kUuid, group_attr_it->second.At(0)->type());
   EXPECT_NE(attributes.end(), group_attr_it);
-  EXPECT_EQ(kPublicBrowseRootUuid, *group_attr_it->second.At(0)->Get<common::UUID>());
+  EXPECT_EQ(kPublicBrowseRootUuid,
+            *group_attr_it->second.At(0)->Get<common::UUID>());
 }
 
 #undef SDP_ERROR_RSP