bluetooth: Move writeValue to mojo

content/renderer/bluetooth/bluetooth_dispatcher.h

 // 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.
 
 #ifndef CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_
 #define CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <queue>
 
 #include "base/id_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/bluetooth/bluetooth_device.h"
+#include "content/common/bluetooth/bluetooth_service.mojom.h"
 #include "content/public/child/worker_thread.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetooth.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothError.h"
 
 namespace base {
 class MessageLoop;
 class TaskRunner;
 }
 
 namespace blink {
 class WebBluetoothRemoteGATTCharacteristic;
 }
 
 namespace IPC {
 class Message;
 }
 
 struct BluetoothCharacteristicRequest;
 struct BluetoothCharacteristicsRequest;
 struct BluetoothPrimaryServiceRequest;
 struct BluetoothWriteValueRequest;
 struct BluetoothNotificationsRequest;
 
 namespace content {
+class ServiceRegistry;
 class ThreadSafeSender;
 
 // Dispatcher for child process threads which communicates to the browser's
 // BluetoothDispatcherHost.
 //
 // Instances are created for each thread as necessary by WebBluetoothImpl.
 //
 // Incoming IPC messages are received by the BluetoothMessageFilter and
 // directed to the thread specific instance of this class.
 // Outgoing messages come from WebBluetoothImpl.
 class BluetoothDispatcher : public WorkerThread::Observer {
  public:
-  explicit BluetoothDispatcher(ThreadSafeSender* sender);
+  explicit BluetoothDispatcher(ThreadSafeSender* sender,
+                               ServiceRegistry* service_registry);
   ~BluetoothDispatcher() override;
 
   // Gets or Creates a BluetoothDispatcher for the current thread.
   // |thread_safe_sender| is required when constructing a BluetoothDispatcher.
   static BluetoothDispatcher* GetOrCreateThreadSpecificInstance(
-      ThreadSafeSender* thread_safe_sender);
+      ThreadSafeSender* thread_safe_sender,
+      ServiceRegistry* service_registry);
 
   // IPC Send and Receiving interface, see IPC::Sender and IPC::Listener.
   bool Send(IPC::Message* msg);
   void OnMessageReceived(const IPC::Message& msg);
 
   // Corresponding to WebBluetoothImpl methods.
   void requestDevice(int frame_routing_id,
                      const blink::WebRequestDeviceOptions& options,
                      blink::WebBluetoothRequestDeviceCallbacks* callbacks);
   void connect(int frame_routing_id,
@@ skipping 139 matching lines @@
       const std::vector<uint32_t>& characteristic_properties);
   void OnGetCharacteristicsError(int thread_id,
                                  int request_id,
                                  blink::WebBluetoothError error);
   void OnReadValueSuccess(int thread_id,
                           int request_id,
                           const std::vector<uint8_t>& value);
   void OnReadValueError(int thread_id,
                         int request_id,
                         blink::WebBluetoothError error);
-  void OnWriteValueSuccess(int thread_id, int request_id);
-  void OnWriteValueError(int thread_id,
-                         int request_id,
-                         blink::WebBluetoothError error);
+  void OnWriteValue(
+      const blink::WebVector<uint8_t>& value,
+      scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
+      blink::mojom::WebBluetoothError error);
   void OnStartNotificationsSuccess(int thread_id, int request_id);
   void OnStartNotificationsError(int thread_id,
                                  int request_id,
                                  blink::WebBluetoothError error);
   void OnStopNotificationsSuccess(int thread_id, int request_id);
   void OnCharacteristicValueChanged(
       int thread_id,
       const std::string& characteristic_instance_id,
       const std::vector<uint8_t> value);
 
+  mojom::BluetoothServicePtr& GetBluetoothService();
+
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
   // Map of characteristic_instance_id to a queue of Notification Requests' IDs.
   // See "Notifications Queueing Note" above.
   std::map<std::string, std::queue<int>> notification_requests_queues_;
 
   // Tracks device requests sent to browser to match replies with callbacks.
   // Owns callback objects.
   IDMap<blink::WebBluetoothRequestDeviceCallbacks, IDMapOwnPointer>
       pending_requests_;
   // Tracks requests to connect to a device.
   // Owns callback objects.
   IDMap<blink::WebBluetoothRemoteGATTServerConnectCallbacks, IDMapOwnPointer>
       pending_connect_requests_;
   // Tracks requests to get a primary service from a device.
   // Owns request objects.
   IDMap<BluetoothPrimaryServiceRequest, IDMapOwnPointer>
       pending_primary_service_requests_;
   // Tracks requests to get a characteristic from a service.
   IDMap<BluetoothCharacteristicRequest, IDMapOwnPointer>
       pending_characteristic_requests_;
   // Tracks requests to get characteristics from a service.
   IDMap<BluetoothCharacteristicsRequest, IDMapOwnPointer>
       pending_characteristics_requests_;
   // Tracks requests to read from a characteristics.
   IDMap<blink::WebBluetoothReadValueCallbacks, IDMapOwnPointer>
       pending_read_value_requests_;
-  IDMap<BluetoothWriteValueRequest, IDMapOwnPointer>
-      pending_write_value_requests_;
   IDMap<BluetoothNotificationsRequest, IDMapOwnPointer>
       pending_notifications_requests_;
 
   // Map of characteristic_instance_id to a set of
   // WebBluetoothRemoteGATTCharacteristic pointers. Keeps track of which
   // objects are subscribed to notifications.
   std::map<std::string, std::set<blink::WebBluetoothRemoteGATTCharacteristic*>>
       active_notification_subscriptions_;
 
   // Map of characteristic_instance_ids to
   // WebBluetoothRemoteGATTCharacteristics.
   // Keeps track of what characteristics have listeners.
   // TODO(ortuno): We are assuming that there exists a single frame per
   // dispatcher, so there could be at most one characteristic object per
   // characteristic_instance_id. Change to a set when we support multiple
   // frames.
   // http://crbug.com/541388
   std::map<std::string, blink::WebBluetoothRemoteGATTCharacteristic*>
       active_characteristics_;
 
+  mojom::BluetoothServicePtr bluetooth_service_;
+
+  ServiceRegistry* service_registry_;
   DISALLOW_COPY_AND_ASSIGN(BluetoothDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_