chrome.bluetooth API improvements.

device/bluetooth/bluetooth_socket_mac.mm

 // Copyright 2013 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_socket_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothRFCOMMChannel.h>
 #import <IOBluetooth/objc/IOBluetoothSDPServiceRecord.h>
 
@@ skipping 105 matching lines @@
           << base::SysNSStringToUTF8([device addressString]) << "): (" << status
           << ")";
     }
   }
 
   // TODO(youngki): Add support for L2CAP sockets as well.
 
   return scoped_refptr<BluetoothSocketMac>(bluetooth_socket);
 }
 
+void BluetoothSocketMac::Release() {
+  NOTIMPLEMENTED();
+}
+
+void BluetoothSocketMac::Disconnect(const base::Closure& callback) {
+  NOTIMPLEMENTED();
+}
+
+void BluetoothSocketMac::Receive(
+    int count,
+    const ReceiveCompletionCallback& success_callback,
+    const ReceiveErrorCompletionCallback& error_callback) {
+  NOTIMPLEMENTED();
+}
+
+void BluetoothSocketMac::Send(scoped_refptr<net::IOBuffer> buffer,
+                              int buffer_size,
+                              const SendCompletionCallback& success_callback,
+                              const ErrorCompletionCallback& error_callback) {
+  NOTIMPLEMENTED();
+}
+
+#if 0
 bool BluetoothSocketMac::Receive(net::GrowableIOBuffer* buffer) {
   CHECK(buffer->offset() == 0);
   int length = incoming_data_buffer_->offset();
   if (length > 0) {
     buffer->SetCapacity(length);
     memcpy(buffer->data(), incoming_data_buffer_->StartOfBuffer(), length);
     buffer->set_offset(length);
 
     ResetIncomingDataBuffer();
   }
@@ skipping 11 matching lines @@
     return false;
   }
 
   buffer->DidConsume(bytes_written);
   return true;
 }
 
 std::string BluetoothSocketMac::GetLastErrorMessage() const {
   return error_message_;
 }
-
+#endif
 void BluetoothSocketMac::OnDataReceived(
     IOBluetoothRFCOMMChannel* rfcomm_channel, void* data, size_t length) {
   DCHECK(rfcomm_channel_ == rfcomm_channel);
   CHECK_LT(length, static_cast<size_t>(std::numeric_limits<int>::max()));
   int data_size = static_cast<int>(length);
   if (incoming_data_buffer_->RemainingCapacity() < data_size) {
     int additional_capacity =
         std::max(data_size, incoming_data_buffer_->capacity());
     CHECK_LT(
         additional_capacity,
         std::numeric_limits<int>::max() - incoming_data_buffer_->capacity());
     incoming_data_buffer_->SetCapacity(
         incoming_data_buffer_->capacity() + additional_capacity);
   }
   memcpy(incoming_data_buffer_->data(), data, data_size);
   incoming_data_buffer_->set_offset(
       incoming_data_buffer_->offset() + data_size);
 }
 
 void BluetoothSocketMac::ResetIncomingDataBuffer() {
   incoming_data_buffer_ = new net::GrowableIOBuffer();
   incoming_data_buffer_->SetCapacity(1024);
 }
 
 }  // namespace device