bluetooth: Move writeValue to mojo

content/browser/frame_host/render_frame_host_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 45 matching lines @@
 struct FrameMsg_TextTrackSettings_Params;
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 struct FrameHostMsg_ShowPopup_Params;
 #endif
 
 namespace base {
 class FilePath;
 class ListValue;
 }
 
+namespace blink {
+namespace mojom {
+class WebBluetoothService;
+}
+}
+
 namespace content {
 
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class FrameMojoShell;
 class FrameTree;
 class FrameTreeNode;
 class NavigationHandleImpl;
 class PermissionServiceContext;
 class RenderFrameHostDelegate;
 class RenderFrameProxyHost;
 class RenderProcessHost;
 class RenderViewHostImpl;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 class RenderWidgetHostViewBase;
 class ResourceRequestBody;
 class StreamHandle;
 class TimeoutMonitor;
+class WebBluetoothServiceImpl;
 struct ContextMenuParams;
 struct GlobalRequestID;
 struct Referrer;
 struct ResourceResponse;
 
 class CONTENT_EXPORT RenderFrameHostImpl : public RenderFrameHost,
                                            public BrowserAccessibilityDelegate,
                                            public SiteInstanceImpl::Observer {
  public:
   using AXTreeSnapshotCallback =
@@ skipping 633 matching lines @@
       const content::StartNavigationParams& start_params,
       const content::RequestNavigationParams& request_params);
 
   // Returns the child FrameTreeNode if |child_frame_routing_id| is an
   // immediate child of this FrameTreeNode.  |child_frame_routing_id| is
   // considered untrusted, so the renderer process is killed if it refers to a
   // FrameTreeNode that is not a child of this node.
   FrameTreeNode* FindAndVerifyChild(int32_t child_frame_routing_id,
                                     bad_message::BadMessageReason reason);
 
+  // Creates a Web Bluetooth Service owned by the frame.
+  void CreateWebBluetoothService(
+      mojo::InterfaceRequest<blink::mojom::WebBluetoothService> request);
+
   // Allows tests to disable the swapout event timer to simulate bugs that
   // happen before it fires (to avoid flakiness).
   void ResetSwapOutTimerForTesting();
 
   // For now, RenderFrameHosts indirectly keep RenderViewHosts alive via a
   // refcount that calls Shutdown when it reaches zero.  This allows each
   // RenderFrameHostManager to just care about RenderFrameHosts, while ensuring
   // we have a RenderViewHost for each RenderFrameHost.
   // TODO(creis): RenderViewHost will eventually go away and be replaced with
   // some form of page context.
@@ skipping 123 matching lines @@
   // long to execute, depending on the number of active frames in the
   // SiteInstance.
   scoped_ptr<TimeoutMonitor> swapout_event_monitor_timeout_;
 
   scoped_ptr<ServiceRegistryImpl> service_registry_;
 
 #if defined(OS_ANDROID)
   scoped_ptr<ServiceRegistryAndroid> service_registry_android_;
 #endif
 
+  scoped_ptr<WebBluetoothServiceImpl> web_bluetooth_service_;

[scheib, 2016/03/31 04:17:51]

WebBluetoothServiceImpl implies that it would prefer to have a StrongBinding
that had the Impl destruct when the pipe closes. It could, it seems, if
RenderFrameHostImpl a weak pointer here and destroyed the
WebBluetoothServiceImpl in ~RenderFrameHostImpl.

But, current code pattern seems fine, which makes me think the comment is too
strong in WebBluetoothServiceImpl "so we can't use the self-deleting behavior of
a StrongBinding" -- it implies that there's a deficiency to not using
StrongBinding.

[Jeffrey Yasskin, 2016/03/31 15:26:16]

That wording comes from  me, I think. My idea was that it's always nicer not to
have a half-working object: if the pipe is closed but the object still exists,
that's one extra state to deal with. If we can use a StrongBinding, then that
state doesn't exist by construction. But here, we need to call into the object
via the RenderFrameHost, so we either have the half-working state in
WebBluetoothServiceImpl or in RenderFrameHost, and maybe it's simpler to
encapsulate it in WebBluetoothServiceImpl. I don't have a strong opinion about
which to use, but the comments should explain why we used the one we did.

[ortuno, 2016/03/31 16:56:44]

When I was designing this I had to decide between using a "Binding" and having
the frame own the Service or using a StrongBinding and juggle the lifetime of
the service between the pipe closing and the frame being removed (I would have
had to do this by implementing a couple of functions of WebContentsObserver; I
hadn't considered using a WeakPtr in RenderFrameHostImpl)

I thought that making Frame own the service would make it much easier to reason
about the lifetime of the service and would result in less code.

I changed the comment for binding_.

+
   // The object managing the accessibility tree for this frame.
   scoped_ptr<BrowserAccessibilityManager> browser_accessibility_manager_;
 
   // This is nonzero if we sent an accessibility reset to the renderer and
   // we're waiting for an IPC containing this reset token (sequentially
   // assigned) and a complete replacement accessibility tree.
   int accessibility_reset_token_;
 
   // A count of the number of times we needed to reset accessibility, so
   // we don't keep trying to reset forever.
@@ skipping 63 matching lines @@
 
   // NOTE: This must be the last member.
   base::WeakPtrFactory<RenderFrameHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_