Remove the Copresence Endpoints API.

components/copresence_endpoints/copresence_endpoint.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 "components/copresence_endpoints/public/copresence_endpoint.h"
-
-#include <stdint.h>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/format_macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/strings/string_number_conversions.h"
-#include "components/copresence_endpoints/transports/bluetooth/copresence_socket_bluetooth.h"
-#include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
-#include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_socket.h"
-#include "device/bluetooth/bluetooth_uuid.h"
-
-namespace {
-
-const char kAdapterError[] = "NOADAPTER";
-const char kSocketServiceUuid[] = "2491fb14-0077-4d4d-bd41-b18e9a570f56";
-
-// This class will confirm pairing for a device that is expecting a pairing
-// confirmation.
-class DefaultApprovalDelegate
-    : public device::BluetoothDevice::PairingDelegate {
- public:
-  DefaultApprovalDelegate() {}
-  ~DefaultApprovalDelegate() override {}
-
-  // device::BluetoothDevice::PairingDelegate overrides:
-  void RequestPinCode(device::BluetoothDevice* device) override {}
-  void RequestPasskey(device::BluetoothDevice* device) override {}
-  void DisplayPinCode(device::BluetoothDevice* device,
-                      const std::string& pincode) override {}
-  void DisplayPasskey(device::BluetoothDevice* device,
-                      uint32 passkey) override {}
-  void KeysEntered(device::BluetoothDevice* device, uint32 entered) override {}
-  void ConfirmPasskey(device::BluetoothDevice* device,
-                      uint32 passkey) override {}
-  void AuthorizePairing(device::BluetoothDevice* device) override {
-    if (device->ExpectingConfirmation())
-      device->ConfirmPairing();
-  }
-};
-
-}  // namespace
-
-namespace copresence_endpoints {
-
-CopresenceEndpoint::CopresenceEndpoint(
-    int endpoint_id,
-    const CreateEndpointCallback& create_callback,
-    const base::Closure& accept_callback,
-    const CopresenceSocket::ReceiveCallback& receive_callback)
-    : endpoint_id_(endpoint_id),
-      create_callback_(create_callback),
-      accept_callback_(accept_callback),
-      receive_callback_(receive_callback),
-      delegate_(nullptr),
-      weak_ptr_factory_(this) {
-  CHECK(!create_callback.is_null());
-  CHECK(!accept_callback.is_null());
-  CHECK(!receive_callback.is_null());
-
-  if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
-    create_callback_.Run(std::string());
-    return;
-  }
-
-  device::BluetoothAdapterFactory::GetAdapter(base::Bind(
-      &CopresenceEndpoint::OnGetAdapter, weak_ptr_factory_.GetWeakPtr()));
-}
-
-CopresenceEndpoint::~CopresenceEndpoint() {
-  server_socket_->Disconnect(base::Bind(&base::DoNothing));
-  server_socket_->Close();
-  if (delegate_)
-    adapter_->RemovePairingDelegate(delegate_.get());
-}
-
-std::string CopresenceEndpoint::GetLocator() {
-  if (!adapter_.get())
-    return kAdapterError;
-  return base::IntToString(endpoint_id_) + "." + adapter_->GetAddress() + "." +
-         kSocketServiceUuid;
-}
-
-bool CopresenceEndpoint::Send(const scoped_refptr<net::IOBuffer>& buffer,
-                              int buffer_size) {
-  if (!client_socket_)
-    return false;
-
-  return client_socket_->Send(buffer, buffer_size);
-}
-
-// Private methods.
-
-void CopresenceEndpoint::OnGetAdapter(
-    scoped_refptr<device::BluetoothAdapter> adapter) {
-  if (!adapter.get() || !adapter->IsPresent() || !adapter->IsPowered()) {
-    LOG(WARNING) << "Unable to use BT adapter";
-    create_callback_.Run(std::string());
-    return;
-  }
-
-  adapter_ = adapter;
-  delegate_ = make_scoped_ptr(new DefaultApprovalDelegate());
-  VLOG(2) << "Got Adapter, creating service with UUID: " << kSocketServiceUuid;
-  adapter_->AddPairingDelegate(
-      delegate_.get(),
-      device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
-  adapter_->CreateRfcommService(
-      device::BluetoothUUID(kSocketServiceUuid),
-      device::BluetoothAdapter::ServiceOptions(),
-      base::Bind(&CopresenceEndpoint::OnCreateService,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&CopresenceEndpoint::OnCreateServiceError,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void CopresenceEndpoint::OnCreateService(
-    scoped_refptr<device::BluetoothSocket> socket) {
-  if (!socket.get()) {
-    LOG(WARNING) << "Couldn't create service!";
-    create_callback_.Run(std::string());
-    return;
-  }
-
-  VLOG(3) << "Starting Accept Socket.";
-  server_socket_ = socket;
-  create_callback_.Run(GetLocator());
-  server_socket_->Accept(
-      base::Bind(&CopresenceEndpoint::OnAccept, weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&CopresenceEndpoint::OnAcceptError,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void CopresenceEndpoint::OnCreateServiceError(const std::string& message) {
-  LOG(WARNING) << "Couldn't create Bluetooth service: " << message;
-  create_callback_.Run(std::string());
-}
-
-void CopresenceEndpoint::OnAccept(
-    const device::BluetoothDevice* device,
-    scoped_refptr<device::BluetoothSocket> socket) {
-  if (!socket.get())
-    return;
-  VLOG(3) << "Accepted Socket.";
-  client_socket_.reset(new CopresenceSocketBluetooth(socket));
-  accept_callback_.Run();
-  client_socket_->Receive(receive_callback_);
-}
-
-void CopresenceEndpoint::OnAcceptError(const std::string& message) {
-  LOG(WARNING) << "Couldn't accept Bluetooth connection: " << message;
-}
-
-}  // namespace copresence_endpoints