Update MidiDispatcher to use Mojo Permission Service.

content/renderer/media/midi_dispatcher.cc

 // 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 "content/renderer/media/midi_dispatcher.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "content/common/media/midi_messages.h"
+#include "content/public/common/service_registry.h"
+#include "content/public/renderer/render_frame.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebMIDIPermissionRequest.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
-#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 using blink::WebMIDIPermissionRequest;
 using blink::WebSecurityOrigin;
 
 namespace content {
 
 MidiDispatcher::MidiDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame) {
 }
 
 MidiDispatcher::~MidiDispatcher() {}
 
-bool MidiDispatcher::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(MidiDispatcher, message)
-    IPC_MESSAGE_HANDLER(MidiMsg_SysExPermissionApproved,
-                        OnSysExPermissionApproved)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void MidiDispatcher::requestSysexPermission(
       const WebMIDIPermissionRequest& request) {
-  int bridge_id = requests_.Add(new WebMIDIPermissionRequest(request));
-  WebSecurityOrigin security_origin = request.securityOrigin();
-  GURL url(security_origin.toString());
-  Send(new MidiHostMsg_RequestSysExPermission(routing_id(), bridge_id, url,
-      blink::WebUserGestureIndicator::isProcessingUserGesture()));
+  if (!permission_service_.get()) {
+    render_frame()->GetServiceRegistry()->ConnectToRemoteService(
+        &permission_service_);
+  }
+

[Tom Sepez, 2014/11/24 18:10:02]

Can the connect fail? Do we need to handle that case?

[mlamouri (slow - plz ping), 2014/11/24 18:20:17]

My understanding is that permission_service_ can't be null after calling
ConnectToRemoteService.

[Tom Sepez, 2014/11/24 18:27:09]

OK, can we add a debug assert?

[mlamouri (slow - plz ping), 2014/11/24 18:29:40]

qsr@, do you have some insights about this? It seems that no content/ calls
actually check that a service is null after connecting. Is that an oversight or
would an assert make sense?

[nasko, 2014/11/25 00:30:59]

I'm biased towards adding a (D)CHECK if we never expect it to fail.

[qsr, 2014/11/25 09:38:00]

 The DCHECK is not useful. The service cannot be null. What happens there is
that you create a pair of pipe, connect one to the proxy (the service), and send
the other one away.

 The proxy is initialized. Now, that doesn't mean there will be something on the
other side. If the other side close the pipe without connecting it to an
implementation, all the calls will just be lost.

[mlamouri (slow - plz ping), 2014/11/25 09:48:21]

Thanks for the quick reply Benjamin! :)

+  int permission_request_id =
+      requests_.Add(new WebMIDIPermissionRequest(request));
+
+  permission_service_->RequestPermission(
+      PERMISSION_NAME_MIDI_SYSEX,
+      request.securityOrigin().toString().utf8(),
+      base::Bind(&MidiDispatcher::OnSysExPermissionSet,
+                 base::Unretained(this),
+                 permission_request_id));
 }
 
 void MidiDispatcher::cancelSysexPermissionRequest(
     const WebMIDIPermissionRequest& request) {
   for (Requests::iterator it(&requests_); !it.IsAtEnd(); it.Advance()) {
     WebMIDIPermissionRequest* value = it.GetCurrentValue();
     if (!value->equals(request))
       continue;
     requests_.Remove(it.GetCurrentKey());
     break;
   }
 }
 
-void MidiDispatcher::OnSysExPermissionApproved(int bridge_id,
-                                               bool is_allowed) {
+void MidiDispatcher::OnSysExPermissionSet(int request_id,
+                                          PermissionStatus status) {
   // |request| can be NULL when the request is canceled.
-  WebMIDIPermissionRequest* request = requests_.Lookup(bridge_id);
+  WebMIDIPermissionRequest* request = requests_.Lookup(request_id);
   if (!request)
     return;
-  request->setIsAllowed(is_allowed);
-  requests_.Remove(bridge_id);
+  request->setIsAllowed(status == PERMISSION_STATUS_GRANTED);
+  requests_.Remove(request_id);
 }
 
 }  // namespace content