bluetooth: Move read value to mojo

content/browser/bluetooth/web_bluetooth_service_impl.cc

 // Copyright 2016 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/browser/bluetooth/web_bluetooth_service_impl.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/bluetooth/bluetooth_blacklist.h"
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
@@ skipping 115 matching lines @@
         characteristic_instance_id, mojo::Array<uint8_t>(std::move(value)));
   }
 }
 
 void WebBluetoothServiceImpl::SetClient(
     blink::mojom::WebBluetoothServiceClientAssociatedPtrInfo client) {
   DCHECK(!client_.get());
   client_.Bind(std::move(client));
 }
 
+void WebBluetoothServiceImpl::RemoteCharacteristicReadValue(
+    const mojo::String& characteristic_instance_id,
+    const RemoteCharacteristicReadValueCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RecordWebBluetoothFunctionCall(
+      UMAWebBluetoothFunction::CHARACTERISTIC_READ_VALUE);
+
+  const CacheQueryResult query_result =
+      GetBluetoothDispatcherHost()->QueryCacheForCharacteristic(
+          GetOrigin(), characteristic_instance_id);
+
+  if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
+    return;
+  }
+
+  if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
+    RecordCharacteristicReadValueOutcome(query_result.outcome);
+    callback.Run(query_result.GetWebError(), nullptr /* value */);
+    return;
+  }
+
+  if (BluetoothBlacklist::Get().IsExcludedFromReads(
+          query_result.characteristic->GetUUID())) {
+    RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::BLACKLISTED);
+    callback.Run(blink::mojom::WebBluetoothError::BLACKLISTED_READ,
+                 nullptr /* value */);
+    return;
+  }
+
+  query_result.characteristic->ReadRemoteCharacteristic(
+      base::Bind(&WebBluetoothServiceImpl::OnReadValueSuccess,
+                 weak_ptr_factory_.GetWeakPtr(), callback),
+      base::Bind(&WebBluetoothServiceImpl::OnReadValueFailed,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
 void WebBluetoothServiceImpl::RemoteCharacteristicWriteValue(
     const mojo::String& characteristic_instance_id,
     mojo::Array<uint8_t> value,
     const RemoteCharacteristicWriteValueCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::CHARACTERISTIC_WRITE_VALUE);
 
   // We perform the length check on the renderer side. So if we
   // get a value with length > 512, we can assume it's a hostile
@@ skipping 103 matching lines @@
     // If the frame hasn't subscribed to notifications before we just
     // run the callback.
     callback.Run();
     return;
   }
   notify_session_iter->second->Stop(base::Bind(
       &WebBluetoothServiceImpl::OnStopNotifySessionComplete,
       weak_ptr_factory_.GetWeakPtr(), characteristic_instance_id, callback));
 }
 
+void WebBluetoothServiceImpl::OnReadValueSuccess(
+    const RemoteCharacteristicReadValueCallback& callback,
+    const std::vector<uint8_t>& value) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome::SUCCESS);
+  callback.Run(blink::mojom::WebBluetoothError::SUCCESS,
+               mojo::Array<uint8_t>::From(value));

[Jeffrey Yasskin, 2016/04/15 20:59:35]

Do the by-value and move thing again here. (The caller might not take advantage
of it now, but we can push the optimization through in the future.)

[ortuno, 2016/04/15 21:34:07]

I tried but OnReadValueSuccess needs to be a ValueCallback[1] and that takes a
reference. But maybe I'm missing something?

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/device/bluetooth/b...

[Jeffrey Yasskin, 2016/04/15 21:38:52]

That's a good reason. We should eventually fix that, but no need to try in this
CL.

+}
+
+void WebBluetoothServiceImpl::OnReadValueFailed(
+    const RemoteCharacteristicReadValueCallback& callback,
+    device::BluetoothGattService::GattErrorCode error_code) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  callback.Run(TranslateGATTErrorAndRecord(
+                   error_code, UMAGATTOperation::CHARACTERISTIC_READ),
+               nullptr /* value */);
+}
+
 void WebBluetoothServiceImpl::OnWriteValueSuccess(
     const RemoteCharacteristicWriteValueCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome::SUCCESS);
   callback.Run(blink::mojom::WebBluetoothError::SUCCESS);
 }
 
 void WebBluetoothServiceImpl::OnWriteValueFailed(
     const RemoteCharacteristicWriteValueCallback& callback,
     device::BluetoothGattService::GattErrorCode error_code) {
@@ skipping 45 matching lines @@
     bad_message::BadMessageReason reason) {
   bad_message::ReceivedBadMessage(GetRenderProcessHost(), reason);
   binding_.Close();
 }
 
 url::Origin WebBluetoothServiceImpl::GetOrigin() {
   return render_frame_host_->GetLastCommittedOrigin();
 }
 
 }  // namespace content