bluetooth: Move writeValue to mojo

content/renderer/bluetooth/bluetooth_dispatcher.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 "content/renderer/bluetooth/bluetooth_dispatcher.h"
 
 #include <stddef.h>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 58 matching lines @@
   BluetoothCharacteristicsRequest(
       blink::WebString service_instance_id,
       blink::WebBluetoothGetCharacteristicsCallbacks* callbacks)
       : service_instance_id(service_instance_id), callbacks(callbacks) {}
   ~BluetoothCharacteristicsRequest() {}
 
   blink::WebString service_instance_id;
   scoped_ptr<blink::WebBluetoothGetCharacteristicsCallbacks> callbacks;
 };
 
-// Struct that holds a pending WriteValue request.
-struct BluetoothWriteValueRequest {
-  BluetoothWriteValueRequest(const blink::WebVector<uint8_t>& value,
-                             blink::WebBluetoothWriteValueCallbacks* callbacks)
-      : value(value), callbacks(callbacks) {}
-  ~BluetoothWriteValueRequest() {}
-
-  const blink::WebVector<uint8_t> value;
-  scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks;
-};
-
 // Struct that holds a pending Start/StopNotifications request.
 struct BluetoothNotificationsRequest {
   BluetoothNotificationsRequest(
       int frame_routing_id,
       const std::string characteristic_instance_id,
       blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
       blink::WebBluetoothNotificationsCallbacks* callbacks,
       NotificationsRequestType type)
       : frame_routing_id(frame_routing_id),
         characteristic_instance_id(characteristic_instance_id),
@@ skipping 91 matching lines @@
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicError,
                       OnGetCharacteristicError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsSuccess,
                       OnGetCharacteristicsSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsError,
                       OnGetCharacteristicsError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueSuccess,
                       OnReadValueSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueError,
                       OnReadValueError);
-  IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueSuccess,
-                      OnWriteValueSuccess);
-  IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueError,
-                      OnWriteValueError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsSuccess,
                       OnStartNotificationsSuccess)
   IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsError,
                       OnStartNotificationsError)
   IPC_MESSAGE_HANDLER(BluetoothMsg_StopNotificationsSuccess,
                       OnStopNotificationsSuccess)
   IPC_MESSAGE_HANDLER(BluetoothMsg_CharacteristicValueChanged,
                       OnCharacteristicValueChanged)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 84 matching lines @@
 void BluetoothDispatcher::readValue(
     int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothReadValueCallbacks* callbacks) {
   int request_id = pending_read_value_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_ReadValue(CurrentWorkerId(), request_id,
                                       frame_routing_id,
                                       characteristic_instance_id.utf8()));
 }
 
-void BluetoothDispatcher::writeValue(
-    int frame_routing_id,
-    const blink::WebString& characteristic_instance_id,
-    const blink::WebVector<uint8_t>& value,
-    blink::WebBluetoothWriteValueCallbacks* callbacks) {
-  int request_id = pending_write_value_requests_.Add(
-      new BluetoothWriteValueRequest(value, callbacks));
-  Send(new BluetoothHostMsg_WriteValue(
-      CurrentWorkerId(), request_id, frame_routing_id,
-      characteristic_instance_id.utf8(),
-      std::vector<uint8_t>(value.begin(), value.end())));
-}
-
 void BluetoothDispatcher::startNotifications(
     int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
   int request_id = QueueNotificationRequest(
       frame_routing_id, characteristic_instance_id.utf8(), characteristic,
       callbacks, NotificationsRequestType::START);
   // The Notification subscription's state can change after a request
   // finishes. To avoid resolving with a soon-to-be-invalid state we queue
@@ skipping 428 matching lines @@
                                            int request_id,
                                            WebBluetoothError error) {
   DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
 
   pending_read_value_requests_.Lookup(request_id)
       ->onError(WebBluetoothError(error));
 
   pending_read_value_requests_.Remove(request_id);
 }
 
-void BluetoothDispatcher::OnWriteValueSuccess(int thread_id, int request_id) {
-  DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
-
-  BluetoothWriteValueRequest* request =
-      pending_write_value_requests_.Lookup(request_id);
-  request->callbacks->onSuccess(request->value);
-
-  pending_write_value_requests_.Remove(request_id);
-}
-
-void BluetoothDispatcher::OnWriteValueError(int thread_id,
-                                            int request_id,
-                                            WebBluetoothError error) {
-  DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
-
-  BluetoothWriteValueRequest* request =
-      pending_write_value_requests_.Lookup(request_id);
-  request->callbacks->onError(WebBluetoothError(error));
-
-  pending_write_value_requests_.Remove(request_id);
-}
-
 void BluetoothDispatcher::OnStartNotificationsSuccess(int thread_id,
                                                       int request_id) {
   DCHECK(pending_notifications_requests_.Lookup(request_id)) << request_id;
 
   BluetoothNotificationsRequest* request =
       pending_notifications_requests_.Lookup(request_id);
 
   DCHECK(notification_requests_queues_[request->characteristic_instance_id]
              .front() == request_id);
 
@@ skipping 68 matching lines @@
     int thread_id,
     const std::string& characteristic_instance_id,
     const std::vector<uint8_t> new_value) {
   auto active_iter = active_characteristics_.find(characteristic_instance_id);
   if (active_iter != active_characteristics_.end()) {
     active_iter->second->dispatchCharacteristicValueChanged(new_value);
   }
 }
 
 }  // namespace content