Web MIDI: Remove MIDIAccessor class

After Web MIDI started using mojo, MIDIAccessor,
MIDIAccessInitializer, and MIDIDispatcher classes
do not much work any more.

As the first step to simplify these unnecessary
layering, this patch removes MIDIAccessor layer.

Bug: 582328
Change-Id: I9377d7afab56eefe96f6818d089af54d5f4d80d0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1718465
Auto-Submit: Takashi Toyoshima <toyoshim@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Takashi Toyoshima <toyoshim@chromium.org>
Cr-Commit-Position: refs/heads/master@{#681172}

third_party/blink/renderer/modules/webmidi/BUILD.gn

@@ -10,9 +10,6 @@ blink_modules_sources("webmidi") {
     "midi_access.h",
     "midi_access_initializer.cc",
     "midi_access_initializer.h",
-    "midi_accessor.cc",
-    "midi_accessor.h",
-    "midi_accessor_client.h",
     "midi_connection_event.cc",
     "midi_connection_event.h",
     "midi_dispatcher.cc",

third_party/blink/renderer/modules/webmidi/midi_access.cc

@@ -59,15 +59,15 @@ PortState ToDeviceState(PortState state) {
 }  // namespace
 
 MIDIAccess::MIDIAccess(
-    std::unique_ptr<MIDIAccessor> accessor,
+    std::unique_ptr<MIDIDispatcher> dispatcher,
     bool sysex_enabled,
     const Vector<MIDIAccessInitializer::PortDescriptor>& ports,
     ExecutionContext* execution_context)
     : ContextLifecycleObserver(execution_context),
-      accessor_(std::move(accessor)),
+      dispatcher_(std::move(dispatcher)),
       sysex_enabled_(sysex_enabled),
       has_pending_activity_(false) {
-  accessor_->SetClient(this);
+  dispatcher_->SetClient(this);
   for (const auto& port : ports) {
     if (port.type == MIDIPort::kTypeInput) {
       inputs_.push_back(MIDIInput::Create(this, port.id, port.manufacturer,
@@ -84,7 +84,7 @@ MIDIAccess::MIDIAccess(
 MIDIAccess::~MIDIAccess() = default;
 
 void MIDIAccess::Dispose() {
-  accessor_.reset();
+  dispatcher_.reset();
 }
 
 EventListener* MIDIAccess::onstatechange() {
@@ -198,11 +198,11 @@ void MIDIAccess::SendMIDIData(unsigned port_index,
       port_index >= outputs_.size())
     return;
 
-  accessor_->SendMIDIData(port_index, data, length, time_stamp);
+  dispatcher_->SendMIDIData(port_index, data, length, time_stamp);
 }
 
 void MIDIAccess::ContextDestroyed(ExecutionContext*) {
-  accessor_.reset();
+  dispatcher_.reset();
 }
 
 void MIDIAccess::Trace(blink::Visitor* visitor) {

third_party/blink/renderer/modules/webmidi/midi_access.h

@@ -38,8 +38,7 @@
 #include "third_party/blink/renderer/core/execution_context/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
 #include "third_party/blink/renderer/modules/webmidi/midi_access_initializer.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor_client.h"
+#include "third_party/blink/renderer/modules/webmidi/midi_dispatcher.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
 
@@ -54,22 +53,22 @@ class MIDIOutputMap;
 class MIDIAccess final : public EventTargetWithInlineData,
                          public ActiveScriptWrappable<MIDIAccess>,
                          public ContextLifecycleObserver,
-                         public MIDIAccessorClient {
+                         public MIDIDispatcher::Client {
   DEFINE_WRAPPERTYPEINFO();
   USING_GARBAGE_COLLECTED_MIXIN(MIDIAccess);
   USING_PRE_FINALIZER(MIDIAccess, Dispose);
 
  public:
   static MIDIAccess* Create(
-      std::unique_ptr<MIDIAccessor> accessor,
+      std::unique_ptr<MIDIDispatcher> dispatcher,
       bool sysex_enabled,
       const Vector<MIDIAccessInitializer::PortDescriptor>& ports,
       ExecutionContext* execution_context) {
-    return MakeGarbageCollected<MIDIAccess>(std::move(accessor), sysex_enabled,
-                                            ports, execution_context);
+    return MakeGarbageCollected<MIDIAccess>(
+        std::move(dispatcher), sysex_enabled, ports, execution_context);
   }
 
-  MIDIAccess(std::unique_ptr<MIDIAccessor>,
+  MIDIAccess(std::unique_ptr<MIDIDispatcher>,
              bool sysex_enabled,
              const Vector<MIDIAccessInitializer::PortDescriptor>&,
              ExecutionContext*);
@@ -97,7 +96,7 @@ class MIDIAccess final : public EventTargetWithInlineData,
   // ContextLifecycleObserver
   void ContextDestroyed(ExecutionContext*) override;
 
-  // MIDIAccessorClient
+  // MIDIDispatcher::Client
   void DidAddInputPort(const String& id,
                        const String& manufacturer,
                        const String& name,
@@ -137,7 +136,7 @@ class MIDIAccess final : public EventTargetWithInlineData,
  private:
   void Dispose();
 
-  std::unique_ptr<MIDIAccessor> accessor_;
+  std::unique_ptr<MIDIDispatcher> dispatcher_;
   bool sysex_enabled_;
   bool has_pending_activity_;
   HeapVector<Member<MIDIInput>> inputs_;

third_party/blink/renderer/modules/webmidi/midi_access_initializer.cc

@@ -34,12 +34,12 @@ MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* script_state,
     : ScriptPromiseResolver(script_state), options_(options) {}
 
 void MIDIAccessInitializer::Dispose() {
-  accessor_.reset();
+  dispatcher_.reset();
   permission_service_.reset();
 }
 
 void MIDIAccessInitializer::ContextDestroyed(ExecutionContext* context) {
-  accessor_.reset();
+  dispatcher_.reset();
   permission_service_.reset();
 
   ScriptPromiseResolver::ContextDestroyed(context);
@@ -51,7 +51,6 @@ ScriptPromise MIDIAccessInitializer::Start() {
   // See https://bit.ly/2S0zRAS for task types.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       GetExecutionContext()->GetTaskRunner(TaskType::kMiscPlatformAPI);
-  accessor_ = std::make_unique<MIDIAccessor>(this, task_runner);
 
   ConnectToPermissionService(
       GetExecutionContext(),
@@ -72,7 +71,7 @@ void MIDIAccessInitializer::DidAddInputPort(const String& id,
                                             const String& name,
                                             const String& version,
                                             PortState state) {
-  DCHECK(accessor_);
+  DCHECK(dispatcher_);
   port_descriptors_.push_back(PortDescriptor(
       id, manufacturer, name, MIDIPort::kTypeInput, version, state));
 }
@@ -82,7 +81,7 @@ void MIDIAccessInitializer::DidAddOutputPort(const String& id,
                                              const String& name,
                                              const String& version,
                                              PortState state) {
-  DCHECK(accessor_);
+  DCHECK(dispatcher_);
   port_descriptors_.push_back(PortDescriptor(
       id, manufacturer, name, MIDIPort::kTypeOutput, version, state));
 }
@@ -102,7 +101,7 @@ void MIDIAccessInitializer::DidSetOutputPortState(unsigned port_index,
 }
 
 void MIDIAccessInitializer::DidStartSession(Result result) {
-  DCHECK(accessor_);
+  DCHECK(dispatcher_);
   // We would also have AbortError and SecurityError according to the spec.
   // SecurityError is handled in onPermission(s)Updated().
   switch (result) {
@@ -110,7 +109,7 @@ void MIDIAccessInitializer::DidStartSession(Result result) {
       break;
     case Result::OK:
       return Resolve(MIDIAccess::Create(
-          std::move(accessor_), options_->hasSysex() && options_->sysex(),
+          std::move(dispatcher_), options_->hasSysex() && options_->sysex(),
           port_descriptors_, GetExecutionContext()));
     case Result::NOT_SUPPORTED:
       return Reject(MakeGarbageCollected<DOMException>(
@@ -135,10 +134,20 @@ ExecutionContext* MIDIAccessInitializer::GetExecutionContext() const {
   return ExecutionContext::From(GetScriptState());
 }
 
+void MIDIAccessInitializer::StartSession() {
+  DCHECK(!dispatcher_);
+
+  // See https://bit.ly/2S0zRAS for task types.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      GetExecutionContext()->GetTaskRunner(TaskType::kMiscPlatformAPI);
+  dispatcher_ = std::make_unique<MIDIDispatcher>(task_runner);
+  dispatcher_->SetClient(this);
+}
+
 void MIDIAccessInitializer::OnPermissionsUpdated(PermissionStatus status) {
   permission_service_.reset();
   if (status == PermissionStatus::GRANTED) {
-    accessor_->StartSession();
+    StartSession();
   } else {
     Reject(
         MakeGarbageCollected<DOMException>(DOMExceptionCode::kSecurityError));
@@ -148,7 +157,7 @@ void MIDIAccessInitializer::OnPermissionsUpdated(PermissionStatus status) {
 void MIDIAccessInitializer::OnPermissionUpdated(PermissionStatus status) {
   permission_service_.reset();
   if (status == PermissionStatus::GRANTED) {
-    accessor_->StartSession();
+    StartSession();
   } else {
     Reject(
         MakeGarbageCollected<DOMException>(DOMExceptionCode::kSecurityError));

third_party/blink/renderer/modules/webmidi/midi_access_initializer.h

@@ -12,8 +12,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor_client.h"
+#include "third_party/blink/renderer/modules/webmidi/midi_dispatcher.h"
 #include "third_party/blink/renderer/modules/webmidi/midi_options.h"
 #include "third_party/blink/renderer/modules/webmidi/midi_port.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
@@ -23,7 +22,7 @@ namespace blink {
 class ScriptState;
 
 class MODULES_EXPORT MIDIAccessInitializer : public ScriptPromiseResolver,
-                                             public MIDIAccessorClient {
+                                             public MIDIDispatcher::Client {
   USING_PRE_FINALIZER(MIDIAccessInitializer, Dispose);
 
  public:
@@ -63,7 +62,7 @@ class MODULES_EXPORT MIDIAccessInitializer : public ScriptPromiseResolver,
 
   void Dispose();
 
-  // MIDIAccessorClient
+  // MIDIDispatcher::Client
   void DidAddInputPort(const String& id,
                        const String& manufacturer,
                        const String& name,
@@ -92,10 +91,12 @@ class MODULES_EXPORT MIDIAccessInitializer : public ScriptPromiseResolver,
 
   void ContextDestroyed(ExecutionContext*) override;
 
+  void StartSession();
+
   void OnPermissionsUpdated(mojom::blink::PermissionStatus);
   void OnPermissionUpdated(mojom::blink::PermissionStatus);
 
-  std::unique_ptr<MIDIAccessor> accessor_;
+  std::unique_ptr<MIDIDispatcher> dispatcher_;
   Vector<PortDescriptor> port_descriptors_;
   Member<const MIDIOptions> options_;
 

third_party/blink/renderer/modules/webmidi/midi_accessor.cc

-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/memory/ptr_util.h"
-#include "third_party/blink/public/platform/platform.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor_client.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_dispatcher.h"
-#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
-
-using midi::mojom::blink::PortState;
-using midi::mojom::blink::Result;
-
-namespace blink {
-
-MIDIAccessor::MIDIAccessor(
-    MIDIAccessorClient* client,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : client_(client), task_runner_(std::move(task_runner)) {
-  DCHECK(client);
-}
-
-MIDIAccessor::~MIDIAccessor() = default;
-
-void MIDIAccessor::StartSession() {
-  dispatcher_ = std::make_unique<MIDIDispatcher>(std::move(task_runner_), this);
-}
-
-void MIDIAccessor::SendMIDIData(unsigned port_index,
-                                const unsigned char* data,
-                                wtf_size_t length,
-                                base::TimeTicks time_stamp) {
-  dispatcher_->SendMidiData(port_index, data, length, time_stamp);
-}
-
-void MIDIAccessor::DidAddInputPort(const String& id,
-                                   const String& manufacturer,
-                                   const String& name,
-                                   const String& version,
-                                   PortState state) {
-  client_->DidAddInputPort(id, manufacturer, name, version, state);
-}
-
-void MIDIAccessor::DidAddOutputPort(const String& id,
-                                    const String& manufacturer,
-                                    const String& name,
-                                    const String& version,
-                                    PortState state) {
-  client_->DidAddOutputPort(id, manufacturer, name, version, state);
-}
-
-void MIDIAccessor::DidSetInputPortState(unsigned port_index, PortState state) {
-  client_->DidSetInputPortState(port_index, state);
-}
-
-void MIDIAccessor::DidSetOutputPortState(unsigned port_index, PortState state) {
-  client_->DidSetOutputPortState(port_index, state);
-}
-
-void MIDIAccessor::DidStartSession(Result result) {
-  client_->DidStartSession(result);
-}
-
-void MIDIAccessor::DidReceiveMIDIData(unsigned port_index,
-                                      const unsigned char* data,
-                                      wtf_size_t length,
-                                      base::TimeTicks time_stamp) {
-  client_->DidReceiveMIDIData(port_index, data, length, time_stamp);
-}
-
-}  // namespace blink

third_party/blink/renderer/modules/webmidi/midi_accessor.h

-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_H_
-#define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_H_
-
-#include <memory>
-#include "base/time/time.h"
-#include "media/midi/midi_service.mojom-blink.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_dispatcher.h"
-#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
-
-namespace blink {
-
-class MIDIAccessorClient;
-
-// TODO(https://crbug.com/582328): Remove this class, and call MIDIDispatcher
-// directly.
-class MIDIAccessor final {
-  USING_FAST_MALLOC(MIDIAccessor);
-
- public:
-  MIDIAccessor(MIDIAccessorClient* client,
-               scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-  ~MIDIAccessor();
-
-  void StartSession();
-  void SendMIDIData(unsigned port_index,
-                    const unsigned char* data,
-                    wtf_size_t length,
-                    base::TimeTicks time_stamp);
-  // MIDIAccessInitializer and MIDIAccess are both MIDIAccessClient.
-  // MIDIAccessInitializer is the first client and MIDIAccess takes over it
-  // once the initialization successfully finishes.
-  void SetClient(MIDIAccessorClient* client) { client_ = client; }
-
-  // The following methods are used by MIDIDispatcher to forward messages from
-  // the browser process.
-  void DidAddInputPort(const String& id,
-                       const String& manufacturer,
-                       const String& name,
-                       const String& version,
-                       midi::mojom::PortState);
-  void DidAddOutputPort(const String& id,
-                        const String& manufacturer,
-                        const String& name,
-                        const String& version,
-                        midi::mojom::PortState);
-  void DidSetInputPortState(unsigned port_index, midi::mojom::PortState);
-  void DidSetOutputPortState(unsigned port_index, midi::mojom::PortState);
-  void DidStartSession(midi::mojom::Result);
-  void DidReceiveMIDIData(unsigned port_index,
-                          const unsigned char* data,
-                          wtf_size_t length,
-                          base::TimeTicks time_stamp);
-
- private:
-
-  MIDIAccessorClient* client_;
-  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  std::unique_ptr<MIDIDispatcher> dispatcher_;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_H_

third_party/blink/renderer/modules/webmidi/midi_accessor_client.h

-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_CLIENT_H_
-#define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_CLIENT_H_
-
-#include "base/time/time.h"
-#include "media/midi/midi_service.mojom-blink.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
-#include "third_party/blink/renderer/platform/wtf/forward.h"
-
-namespace blink {
-
-class MIDIAccessorClient {
- public:
-  virtual void DidAddInputPort(const String& id,
-                               const String& manufacturer,
-                               const String& name,
-                               const String& version,
-                               midi::mojom::PortState) = 0;
-  virtual void DidAddOutputPort(const String& id,
-                                const String& manufacturer,
-                                const String& name,
-                                const String& version,
-                                midi::mojom::PortState) = 0;
-  virtual void DidSetInputPortState(unsigned port_index,
-                                    midi::mojom::PortState) = 0;
-  virtual void DidSetOutputPortState(unsigned port_index,
-                                     midi::mojom::PortState) = 0;
-
-  virtual void DidStartSession(midi::mojom::Result) = 0;
-  virtual void DidReceiveMIDIData(unsigned port_index,
-                                  const unsigned char* data,
-                                  wtf_size_t length,
-                                  base::TimeTicks time_stamp) = 0;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_WEBMIDI_MIDI_ACCESSOR_CLIENT_H_

third_party/blink/renderer/modules/webmidi/midi_dispatcher.cc

@@ -9,7 +9,6 @@
 #include "third_party/blink/public/platform/interface_provider.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_string.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
 #include "third_party/blink/renderer/platform/heap/persistent.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
@@ -24,13 +23,9 @@ static const size_t kMaxUnacknowledgedBytesSent = 10 * 1024 * 1024;  // 10 MB.
 }  // namespace
 
 MIDIDispatcher::MIDIDispatcher(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    MIDIAccessor* accessor)
-    : accessor_(accessor),
-      binding_(this),
-      task_runner_(std::move(task_runner)) {
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : binding_(this), task_runner_(std::move(task_runner)) {
   TRACE_EVENT0("midi", "MIDIDispatcher::MIDIDispatcher");
-  DCHECK(accessor_);
   midi::mojom::blink::MidiSessionClientPtr client_ptr;
   binding_.Bind(mojo::MakeRequest(&client_ptr, task_runner_), task_runner_);
 
@@ -42,7 +37,7 @@ MIDIDispatcher::MIDIDispatcher(
 
 MIDIDispatcher::~MIDIDispatcher() = default;
 
-void MIDIDispatcher::SendMidiData(uint32_t port,
+void MIDIDispatcher::SendMIDIData(uint32_t port,
                                   const uint8_t* data,
                                   wtf_size_t length,
                                   base::TimeTicks timestamp) {
@@ -59,58 +54,63 @@ void MIDIDispatcher::SendMidiData(uint32_t port,
 }
 
 void MIDIDispatcher::AddInputPort(midi::mojom::blink::PortInfoPtr info) {
+  DCHECK(client_);
   inputs_.push_back(*info);
   if (initialized_) {
-    accessor_->DidAddInputPort(info->id, info->manufacturer, info->name,
-                               info->version, info->state);
+    client_->DidAddInputPort(info->id, info->manufacturer, info->name,
+                             info->version, info->state);
   }
 }
 
 void MIDIDispatcher::AddOutputPort(midi::mojom::blink::PortInfoPtr info) {
+  DCHECK(client_);
   outputs_.push_back(*info);
   if (initialized_) {
-    accessor_->DidAddOutputPort(info->id, info->manufacturer, info->name,
-                                info->version, info->state);
+    client_->DidAddOutputPort(info->id, info->manufacturer, info->name,
+                              info->version, info->state);
   }
 }
 
 void MIDIDispatcher::SetInputPortState(uint32_t port,
                                        midi::mojom::blink::PortState state) {
+  DCHECK(client_);
   if (inputs_[port].state == state)
     return;
   inputs_[port].state = state;
   if (initialized_)
-    accessor_->DidSetInputPortState(port, state);
+    client_->DidSetInputPortState(port, state);
 }
 
 void MIDIDispatcher::SetOutputPortState(uint32_t port,
                                         midi::mojom::blink::PortState state) {
+  DCHECK(client_);
   if (outputs_[port].state == state)
     return;
   outputs_[port].state = state;
   if (initialized_)
-    accessor_->DidSetOutputPortState(port, state);
+    client_->DidSetOutputPortState(port, state);
 }
 
 void MIDIDispatcher::SessionStarted(midi::mojom::blink::Result result) {
   TRACE_EVENT0("midi", "MIDIDispatcher::OnSessionStarted");
 
   DCHECK(!initialized_);
+  DCHECK(client_);
   initialized_ = true;
 
   if (result == midi::mojom::blink::Result::OK) {
     // Add the accessor's input and output ports.
     for (const auto& info : inputs_) {
-      accessor_->DidAddInputPort(info.id, info.manufacturer, info.name,
-                                 info.version, info.state);
+      client_->DidAddInputPort(info.id, info.manufacturer, info.name,
+                               info.version, info.state);
     }
 
     for (const auto& info : outputs_) {
-      accessor_->DidAddOutputPort(info.id, info.manufacturer, info.name,
-                                  info.version, info.state);
+      client_->DidAddOutputPort(info.id, info.manufacturer, info.name,
+                                info.version, info.state);
     }
   }
-  accessor_->DidStartSession(result);
+  client_->DidStartSession(result);
 }
 
 void MIDIDispatcher::AcknowledgeSentData(uint32_t bytes_sent) {
@@ -122,11 +122,12 @@ void MIDIDispatcher::AcknowledgeSentData(uint32_t bytes_sent) {
 void MIDIDispatcher::DataReceived(uint32_t port,
                                   const Vector<uint8_t>& data,
                                   base::TimeTicks timestamp) {
+  DCHECK(client_);
   TRACE_EVENT0("midi", "MIDIDispatcher::DataReceived");
   DCHECK(!data.IsEmpty());
 
   if (initialized_)
-    accessor_->DidReceiveMIDIData(port, &data[0], data.size(), timestamp);
+    client_->DidReceiveMIDIData(port, &data[0], data.size(), timestamp);
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/webmidi/midi_dispatcher.h

@@ -12,15 +12,39 @@
 
 namespace blink {
 
-class MIDIAccessor;
-
 class MIDIDispatcher : public midi::mojom::blink::MidiSessionClient {
  public:
-  MIDIDispatcher(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                 MIDIAccessor* accessor);
+  class Client {
+   public:
+    virtual void DidAddInputPort(const String& id,
+                                 const String& manufacturer,
+                                 const String& name,
+                                 const String& version,
+                                 midi::mojom::PortState) = 0;
+    virtual void DidAddOutputPort(const String& id,
+                                  const String& manufacturer,
+                                  const String& name,
+                                  const String& version,
+                                  midi::mojom::PortState) = 0;
+    virtual void DidSetInputPortState(unsigned port_index,
+                                      midi::mojom::PortState) = 0;
+    virtual void DidSetOutputPortState(unsigned port_index,
+                                       midi::mojom::PortState) = 0;
+
+    virtual void DidStartSession(midi::mojom::Result) = 0;
+    virtual void DidReceiveMIDIData(unsigned port_index,
+                                    const unsigned char* data,
+                                    wtf_size_t length,
+                                    base::TimeTicks time_stamp) = 0;
+  };
+
+  explicit MIDIDispatcher(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~MIDIDispatcher() override;
 
-  void SendMidiData(uint32_t port,
+  void SetClient(Client* client) { client_ = client; }
+
+  void SendMIDIData(uint32_t port,
                     const uint8_t* data,
                     wtf_size_t length,
                     base::TimeTicks timestamp);
@@ -40,9 +64,7 @@ class MIDIDispatcher : public midi::mojom::blink::MidiSessionClient {
                     base::TimeTicks timestamp) override;
 
  private:
-  // Keeps track of a MIDI accessor. As a MIDIAccessor owns a MIDIDispatcher, a
-  // raw pointer is fine.
-  MIDIAccessor* const accessor_;
+  Client* client_ = nullptr;
 
   bool initialized_ = false;
 

third_party/blink/renderer/modules/webmidi/midi_input.h

@@ -33,7 +33,6 @@
 
 #include "media/midi/midi_service.mojom-blink.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
 #include "third_party/blink/renderer/modules/webmidi/midi_port.h"
 
 namespace blink {

third_party/blink/renderer/modules/webmidi/midi_port.h

@@ -37,7 +37,6 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/core/execution_context/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
-#include "third_party/blink/renderer/modules/webmidi/midi_accessor.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
 namespace blink {