Web MIDI: rename DynamicallyInitializedMidiManagerWin

media/midi/midi_manager_win.cc

 // Copyright 2017 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 "media/midi/dynamically_initialized_midi_manager_win.h"
+#include "media/midi/midi_manager_win.h"
 
 #include <windows.h>
 
 #include <ks.h>
 #include <ksmedia.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 11 matching lines @@
 #include "media/midi/message_util.h"
 #include "media/midi/midi_manager_winrt.h"
 #include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.h"
 #include "media/midi/midi_switches.h"
 
 namespace midi {
 
 // Forward declaration of PortManager for anonymous functions and internal
 // classes to use it.
-class DynamicallyInitializedMidiManagerWin::PortManager {
+class MidiManagerWin::PortManager {
  public:
   // Calculates event time from elapsed time that system provides.
   base::TimeTicks CalculateInEventTime(size_t index, uint32_t elapsed_ms) const;
 
   // Registers HMIDIIN handle to resolve port index.
   void RegisterInHandle(HMIDIIN handle, size_t index);
 
   // Unregisters HMIDIIN handle.
   void UnregisterInHandle(HMIDIIN handle);
 
@@ skipping 49 matching lines @@
 // TODO(toyoshim): Consider to use linked small buffers so that midiOutReset()
 // can abort sending unhandled following buffers.
 constexpr size_t kSysExSizeLimit = 256 * 1024;
 
 // Defines input buffer size.
 constexpr size_t kBufferLength = 32 * 1024;
 
 // Global variables to identify MidiManager instance.
 constexpr int kInvalidInstanceId = -1;
 int g_active_instance_id = kInvalidInstanceId;
-DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr;
+MidiManagerWin* g_manager_instance = nullptr;
 
 // Obtains base::Lock instance pointer to lock instance_id.
 base::Lock* GetInstanceIdLock() {
   static base::Lock* lock = new base::Lock;
   return lock;
 }
 
 // Issues unique MidiManager instance ID.
 int IssueNextInstanceId() {
   static int id = kInvalidInstanceId;
@@ skipping 171 matching lines @@
   uint32_t device_id_;
   const uint16_t manufacturer_id_;
   const uint16_t product_id_;
   const uint32_t driver_version_;
   const std::string product_name_;
   MidiPortInfo info_;
 };  // class Port
 
 }  // namespace
 
-class DynamicallyInitializedMidiManagerWin::InPort final : public Port {
+class MidiManagerWin::InPort final : public Port {
  public:
-  InPort(DynamicallyInitializedMidiManagerWin* manager,
+  InPort(MidiManagerWin* manager,
          int instance_id,
          UINT device_id,
          const MIDIINCAPS2W& caps)
       : Port("input",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
                  base::string16(caps.szPname, wcslen(caps.szPname))),
              caps.ManufacturerGuid),
         manager_(manager),
         in_handle_(kInvalidInHandle),
         instance_id_(instance_id) {}
 
   static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts(
-      DynamicallyInitializedMidiManagerWin* manager,
+      MidiManagerWin* manager,
       int instance_id) {
     std::vector<std::unique_ptr<InPort>> ports;
     const UINT num_devices = midiInGetNumDevs();
     for (UINT device_id = 0; device_id < num_devices; ++device_id) {
       MIDIINCAPS2W caps;
       MMRESULT result = midiInGetDevCaps(
           device_id, reinterpret_cast<LPMIDIINCAPSW>(&caps), sizeof(caps));
       if (result != MMSYSERR_NOERROR) {
         LOG(ERROR) << "midiInGetDevCaps fails on device " << device_id;
         continue;
       }
       ports.push_back(
           base::MakeUnique<InPort>(manager, instance_id, device_id, caps));
     }
     return ports;
   }
 
   void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
     if (in_handle_ != kInvalidInHandle) {
-      runner->PostTask(
-          FROM_HERE,
-          base::Bind(&FinalizeInPort, in_handle_, base::Passed(&hdr_)));
+      runner->PostTask(FROM_HERE, base::Bind(&FinalizeInPort, in_handle_,
+                                             base::Passed(&hdr_)));
       manager_->port_manager()->UnregisterInHandle(in_handle_);
       in_handle_ = kInvalidInHandle;
     }
   }
 
   base::TimeTicks CalculateInEventTime(uint32_t elapsed_ms) const {
     return start_time_ + base::TimeDelta::FromMilliseconds(elapsed_ms);
   }
 
   void RestoreBuffer() {
     if (in_handle_ == kInvalidInHandle || !hdr_)
       return;
     midiInAddBuffer(in_handle_, hdr_.get(), sizeof(*hdr_));
   }
 
-  void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) {
-    manager->PostReplyTask(
-        base::Bind(&DynamicallyInitializedMidiManagerWin::SetInputPortState,
-                   base::Unretained(manager), index_, info_.state));
+  void NotifyPortStateSet(MidiManagerWin* manager) {
+    manager->PostReplyTask(base::Bind(&MidiManagerWin::SetInputPortState,
+                                      base::Unretained(manager), index_,
+                                      info_.state));
   }
 
-  void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) {
-    manager->PostReplyTask(
-        base::Bind(&DynamicallyInitializedMidiManagerWin::AddInputPort,
-                   base::Unretained(manager), info_));
+  void NotifyPortAdded(MidiManagerWin* manager) {
+    manager->PostReplyTask(base::Bind(&MidiManagerWin::AddInputPort,
+                                      base::Unretained(manager), info_));
   }
 
   // Port overrides:
   bool Disconnect() override {
     if (in_handle_ != kInvalidInHandle) {
       // Following API call may fail because device was already disconnected.
       // But just in case.
       midiInClose(in_handle_);
       manager_->port_manager()->UnregisterInHandle(in_handle_);
       in_handle_ = kInvalidInHandle;
@@ skipping 25 matching lines @@
         midiInUnprepareHeader(in_handle_, hdr_.get(), sizeof(*hdr_));
         hdr_.reset();
         midiInClose(in_handle_);
         in_handle_ = kInvalidInHandle;
       }
       Disconnect();
     }
   }
 
  private:
-  DynamicallyInitializedMidiManagerWin* manager_;
+  MidiManagerWin* manager_;
   HMIDIIN in_handle_;
   ScopedMIDIHDR hdr_;
   base::TimeTicks start_time_;
   const int instance_id_;
 };
 
-class DynamicallyInitializedMidiManagerWin::OutPort final : public Port {
+class MidiManagerWin::OutPort final : public Port {
  public:
   OutPort(UINT device_id, const MIDIOUTCAPS2W& caps)
       : Port("output",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
                  base::string16(caps.szPname, wcslen(caps.szPname))),
              caps.ManufacturerGuid),
@@ skipping 16 matching lines @@
     return ports;
   }
 
   void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
     if (out_handle_ != kInvalidOutHandle) {
       runner->PostTask(FROM_HERE, base::Bind(&FinalizeOutPort, out_handle_));
       out_handle_ = kInvalidOutHandle;
     }
   }
 
-  void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) {
-    manager->PostReplyTask(
-        base::Bind(&DynamicallyInitializedMidiManagerWin::SetOutputPortState,
-                   base::Unretained(manager), index_, info_.state));
+  void NotifyPortStateSet(MidiManagerWin* manager) {
+    manager->PostReplyTask(base::Bind(&MidiManagerWin::SetOutputPortState,
+                                      base::Unretained(manager), index_,
+                                      info_.state));
   }
 
-  void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) {
-    manager->PostReplyTask(
-        base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort,
-                   base::Unretained(manager), info_));
+  void NotifyPortAdded(MidiManagerWin* manager) {
+    manager->PostReplyTask(base::Bind(&MidiManagerWin::AddOutputPort,
+                                      base::Unretained(manager), info_));
   }
 
   void Send(const std::vector<uint8_t>& data) {
     if (out_handle_ == kInvalidOutHandle)
       return;
 
     if (data.size() <= 3) {
       uint32_t message = 0;
       for (size_t i = 0; i < data.size(); ++i)
         message |= (static_cast<uint32_t>(data[i]) << (i * 8));
@@ skipping 52 matching lines @@
     } else {
       out_handle_ = kInvalidOutHandle;
       Disconnect();
     }
   }
 
   const bool software_;
   HMIDIOUT out_handle_;
 };
 
-base::TimeTicks
-DynamicallyInitializedMidiManagerWin::PortManager::CalculateInEventTime(
+base::TimeTicks MidiManagerWin::PortManager::CalculateInEventTime(
     size_t index,
     uint32_t elapsed_ms) const {
   GetTaskLock()->AssertAcquired();
   CHECK_GT(input_ports_.size(), index);
   return input_ports_[index]->CalculateInEventTime(elapsed_ms);
 }
 
-void DynamicallyInitializedMidiManagerWin::PortManager::RegisterInHandle(
-    HMIDIIN handle,
-    size_t index) {
+void MidiManagerWin::PortManager::RegisterInHandle(HMIDIIN handle,
+                                                   size_t index) {
   GetTaskLock()->AssertAcquired();
   hmidiin_to_index_map_[handle] = index;
 }
 
-void DynamicallyInitializedMidiManagerWin::PortManager::UnregisterInHandle(
-    HMIDIIN handle) {
+void MidiManagerWin::PortManager::UnregisterInHandle(HMIDIIN handle) {
   GetTaskLock()->AssertAcquired();
   hmidiin_to_index_map_.erase(handle);
 }
 
-bool DynamicallyInitializedMidiManagerWin::PortManager::FindInHandle(
-    HMIDIIN hmi,
-    size_t* out_index) {
+bool MidiManagerWin::PortManager::FindInHandle(HMIDIIN hmi, size_t* out_index) {
   GetTaskLock()->AssertAcquired();
   auto found = hmidiin_to_index_map_.find(hmi);
   if (found == hmidiin_to_index_map_.end())
     return false;
   *out_index = found->second;
   return true;
 }
 
-void DynamicallyInitializedMidiManagerWin::PortManager::RestoreInBuffer(
-    size_t index) {
+void MidiManagerWin::PortManager::RestoreInBuffer(size_t index) {
   GetTaskLock()->AssertAcquired();
   CHECK_GT(input_ports_.size(), index);
   input_ports_[index]->RestoreBuffer();
 }
 
 void CALLBACK
-DynamicallyInitializedMidiManagerWin::PortManager::HandleMidiInCallback(
-    HMIDIIN hmi,
-    UINT msg,
-    DWORD_PTR instance,
-    DWORD_PTR param1,
-    DWORD_PTR param2) {
+MidiManagerWin::PortManager::HandleMidiInCallback(HMIDIIN hmi,
+                                                  UINT msg,
+                                                  DWORD_PTR instance,
+                                                  DWORD_PTR param1,
+                                                  DWORD_PTR param2) {
   if (msg != MIM_DATA && msg != MIM_LONGDATA)
     return;
   int instance_id = static_cast<int>(instance);
-  DynamicallyInitializedMidiManagerWin* manager = nullptr;
+  MidiManagerWin* manager = nullptr;
 
   // Use |g_task_lock| so to ensure the instance can keep alive while running,
   // and to access member variables that are used on TaskRunner.
   base::AutoLock task_lock(*GetTaskLock());
   {
     base::AutoLock lock(*GetInstanceIdLock());
     if (instance_id != g_active_instance_id)
       return;
     manager = g_manager_instance;
   }
 
   size_t index;
   if (!manager->port_manager()->FindInHandle(hmi, &index))
     return;
 
   DCHECK(msg == MIM_DATA || msg == MIM_LONGDATA);
   if (msg == MIM_DATA) {
     const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
     const uint8_t first_data_byte = static_cast<uint8_t>((param1 >> 8) & 0xff);
     const uint8_t second_data_byte =
         static_cast<uint8_t>((param1 >> 16) & 0xff);
     const uint8_t kData[] = {status_byte, first_data_byte, second_data_byte};
     const size_t len = GetMessageLength(status_byte);
     DCHECK_LE(len, arraysize(kData));
     std::vector<uint8_t> data;
     data.assign(kData, kData + len);
     manager->PostReplyTask(base::Bind(
-        &DynamicallyInitializedMidiManagerWin::ReceiveMidiData,
-        base::Unretained(manager), index, data,
-        manager->port_manager()->CalculateInEventTime(index, param2)));
+        &MidiManagerWin::ReceiveMidiData, base::Unretained(manager), index,
+        data, manager->port_manager()->CalculateInEventTime(index, param2)));
   } else {
     DCHECK_EQ(static_cast<UINT>(MIM_LONGDATA), msg);
     LPMIDIHDR hdr = reinterpret_cast<LPMIDIHDR>(param1);
     if (hdr->dwBytesRecorded > 0) {
       const uint8_t* src = reinterpret_cast<const uint8_t*>(hdr->lpData);
       std::vector<uint8_t> data;
       data.assign(src, src + hdr->dwBytesRecorded);
       manager->PostReplyTask(base::Bind(
-          &DynamicallyInitializedMidiManagerWin::ReceiveMidiData,
-          base::Unretained(manager), index, data,
-          manager->port_manager()->CalculateInEventTime(index, param2)));
+          &MidiManagerWin::ReceiveMidiData, base::Unretained(manager), index,
+          data, manager->port_manager()->CalculateInEventTime(index, param2)));
     }
-    manager->PostTask(base::Bind(
-        &DynamicallyInitializedMidiManagerWin::PortManager::RestoreInBuffer,
-        base::Unretained(manager->port_manager()), index));
+    manager->PostTask(base::Bind(&MidiManagerWin::PortManager::RestoreInBuffer,
+                                 base::Unretained(manager->port_manager()),
+                                 index));
   }
 }
 
 void CALLBACK
-DynamicallyInitializedMidiManagerWin::PortManager::HandleMidiOutCallback(
-    HMIDIOUT hmo,
-    UINT msg,
-    DWORD_PTR instance,
-    DWORD_PTR param1,
-    DWORD_PTR param2) {
+MidiManagerWin::PortManager::HandleMidiOutCallback(HMIDIOUT hmo,
+                                                   UINT msg,
+                                                   DWORD_PTR instance,
+                                                   DWORD_PTR param1,
+                                                   DWORD_PTR param2) {
   if (msg == MOM_DONE) {
     ScopedMIDIHDR hdr(reinterpret_cast<LPMIDIHDR>(param1));
     if (!hdr)
       return;
     // TODO(toyoshim): Call midiOutUnprepareHeader outside the callback.
     // Since this callback may be invoked after the manager is destructed,
     // and can not send a task to the TaskRunner in such case, we need to
     // consider to track MIDIHDR per port, and clean it in port finalization
     // steps, too.
     midiOutUnprepareHeader(hmo, hdr.get(), sizeof(*hdr));
   }
 }
 
-DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin(
-    MidiService* service)
+MidiManagerWin::MidiManagerWin(MidiService* service)
     : MidiManager(service),
       instance_id_(IssueNextInstanceId()),
       port_manager_(base::MakeUnique<PortManager>()) {
   base::AutoLock lock(*GetInstanceIdLock());
   CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 
   // Obtains the task runner for the current thread that hosts this instnace.
   thread_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
-DynamicallyInitializedMidiManagerWin::~DynamicallyInitializedMidiManagerWin() {
+MidiManagerWin::~MidiManagerWin() {
   base::AutoLock lock(*GetInstanceIdLock());
   CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
   CHECK(thread_runner_->BelongsToCurrentThread());
 }
 
-void DynamicallyInitializedMidiManagerWin::StartInitialization() {
+void MidiManagerWin::StartInitialization() {
   {
     base::AutoLock lock(*GetInstanceIdLock());
     CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
     g_active_instance_id = instance_id_;
     CHECK_EQ(nullptr, g_manager_instance);
     g_manager_instance = this;
   }
   // Registers on the I/O thread to be notified on the I/O thread.
   CHECK(thread_runner_->BelongsToCurrentThread());
   base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
 
   // Starts asynchronous initialization on TaskRunner.
-  PostTask(
-      base::Bind(&DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner,
-                 base::Unretained(this)));
+  PostTask(base::Bind(&MidiManagerWin::InitializeOnTaskRunner,
+                      base::Unretained(this)));
 }
 
-void DynamicallyInitializedMidiManagerWin::Finalize() {
+void MidiManagerWin::Finalize() {
   // Unregisters on the I/O thread. OnDevicesChanged() won't be called any more.
   CHECK(thread_runner_->BelongsToCurrentThread());
   base::SystemMonitor::Get()->RemoveDevicesChangedObserver(this);
   {
     base::AutoLock lock(*GetInstanceIdLock());
     CHECK_EQ(instance_id_, g_active_instance_id);
     g_active_instance_id = kInvalidInstanceId;
     CHECK_EQ(this, g_manager_instance);
     g_manager_instance = nullptr;
   }
 
   // Ensures that no task runs on TaskRunner so to destruct the instance safely.
   // Tasks that did not started yet will do nothing after invalidate the
   // instance ID above.
   // Behind the lock below, we can safely access all members for finalization
   // even on the I/O thread.
   base::AutoLock lock(*GetTaskLock());
 
   // Posts tasks that finalize each device port without MidiManager instance
   // on TaskRunner. If another MidiManager instance is created, its
   // initialization runs on the same task runner after all tasks posted here
   // finish.
   for (const auto& port : *port_manager_->inputs())
     port->Finalize(service()->GetTaskRunner(kTaskRunner));
   for (const auto& port : *port_manager_->outputs())
     port->Finalize(service()->GetTaskRunner(kTaskRunner));
 }
 
-void DynamicallyInitializedMidiManagerWin::DispatchSendMidiData(
-    MidiManagerClient* client,
-    uint32_t port_index,
-    const std::vector<uint8_t>& data,
-    double timestamp) {
+void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
+                                          uint32_t port_index,
+                                          const std::vector<uint8_t>& data,
+                                          double timestamp) {
   if (timestamp != 0.0) {
-    base::TimeTicks time = base::TimeTicks() +
-                           base::TimeDelta::FromMicroseconds(
-                               timestamp * base::Time::kMicrosecondsPerSecond);
+    base::TimeTicks time =
+        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
+                                timestamp * base::Time::kMicrosecondsPerSecond);
     base::TimeTicks now = base::TimeTicks::Now();
     if (now < time) {
       PostDelayedTask(
-          base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
-                     base::Unretained(this), client, port_index, data),
+          base::Bind(&MidiManagerWin::SendOnTaskRunner, base::Unretained(this),
+                     client, port_index, data),
           time - now);
       return;
     }
   }
-  PostTask(base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
-                      base::Unretained(this), client, port_index, data));
+  PostTask(base::Bind(&MidiManagerWin::SendOnTaskRunner, base::Unretained(this),
+                      client, port_index, data));
 }
 
-void DynamicallyInitializedMidiManagerWin::OnDevicesChanged(
+void MidiManagerWin::OnDevicesChanged(
     base::SystemMonitor::DeviceType device_type) {
   // Notified on the I/O thread.
   CHECK(thread_runner_->BelongsToCurrentThread());
 
   switch (device_type) {
     case base::SystemMonitor::DEVTYPE_AUDIO:
     case base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE:
       // Add case of other unrelated device types here.
       return;
     case base::SystemMonitor::DEVTYPE_UNKNOWN: {
-      PostTask(base::Bind(
-          &DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner,
-          base::Unretained(this)));
+      PostTask(base::Bind(&MidiManagerWin::UpdateDeviceListOnTaskRunner,
+                          base::Unretained(this)));
       break;
     }
   }
 }
 
-void DynamicallyInitializedMidiManagerWin::ReceiveMidiData(
-    uint32_t index,
-    const std::vector<uint8_t>& data,
-    base::TimeTicks time) {
+void MidiManagerWin::ReceiveMidiData(uint32_t index,
+                                     const std::vector<uint8_t>& data,
+                                     base::TimeTicks time) {
   MidiManager::ReceiveMidiData(index, data.data(), data.size(), time);
 }
 
-void DynamicallyInitializedMidiManagerWin::PostTask(const base::Closure& task) {
+void MidiManagerWin::PostTask(const base::Closure& task) {
   service()
       ->GetTaskRunner(kTaskRunner)
       ->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
 }
 
-void DynamicallyInitializedMidiManagerWin::PostDelayedTask(
-    const base::Closure& task,
-    base::TimeDelta delay) {
+void MidiManagerWin::PostDelayedTask(const base::Closure& task,
+                                     base::TimeDelta delay) {
   service()
       ->GetTaskRunner(kTaskRunner)
       ->PostDelayedTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task),
                         delay);
 }
 
-void DynamicallyInitializedMidiManagerWin::PostReplyTask(
-    const base::Closure& task) {
+void MidiManagerWin::PostReplyTask(const base::Closure& task) {
   thread_runner_->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
 }
 
-void DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner() {
+void MidiManagerWin::InitializeOnTaskRunner() {
   UpdateDeviceListOnTaskRunner();
-  PostReplyTask(
-      base::Bind(&DynamicallyInitializedMidiManagerWin::CompleteInitialization,
-                 base::Unretained(this), mojom::Result::OK));
+  PostReplyTask(base::Bind(&MidiManagerWin::CompleteInitialization,
+                           base::Unretained(this), mojom::Result::OK));
 }
 
-void DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner() {
+void MidiManagerWin::UpdateDeviceListOnTaskRunner() {
   std::vector<std::unique_ptr<InPort>> active_input_ports =
       InPort::EnumerateActivePorts(this, instance_id_);
   ReflectActiveDeviceList(this, port_manager_->inputs(), &active_input_ports);
 
   std::vector<std::unique_ptr<OutPort>> active_output_ports =
       OutPort::EnumerateActivePorts();
   ReflectActiveDeviceList(this, port_manager_->outputs(), &active_output_ports);
 
   // TODO(toyoshim): This method may run before internal MIDI device lists that
   // Windows manages were updated. This may be because MIDI driver may be loaded
   // after the raw device list was updated. To avoid this problem, we may want
   // to retry device check later if no changes are detected here.
 }
 
 template <typename T>
-void DynamicallyInitializedMidiManagerWin::ReflectActiveDeviceList(
-    DynamicallyInitializedMidiManagerWin* manager,
-    std::vector<T>* known_ports,
-    std::vector<T>* active_ports) {
+void MidiManagerWin::ReflectActiveDeviceList(MidiManagerWin* manager,
+                                             std::vector<T>* known_ports,
+                                             std::vector<T>* active_ports) {
   // Update existing port states.
   for (const auto& port : *known_ports) {
     const auto& it = std::find_if(
         active_ports->begin(), active_ports->end(),
         [&port](const auto& candidate) { return *candidate == *port; });
     if (it == active_ports->end()) {
       if (port->Disconnect())
         port->NotifyPortStateSet(this);
     } else {
       port->set_device_id((*it)->device_id());
@@ skipping 10 matching lines @@
                      }) == known_ports->end()) {
       size_t index = known_ports->size();
       port->set_index(index);
       known_ports->push_back(std::move(port));
       (*known_ports)[index]->Connect();
       (*known_ports)[index]->NotifyPortAdded(this);
     }
   }
 }
 
-void DynamicallyInitializedMidiManagerWin::SendOnTaskRunner(
-    MidiManagerClient* client,
-    uint32_t port_index,
-    const std::vector<uint8_t>& data) {
+void MidiManagerWin::SendOnTaskRunner(MidiManagerClient* client,
+                                      uint32_t port_index,
+                                      const std::vector<uint8_t>& data) {
   CHECK_GT(port_manager_->outputs()->size(), port_index);
   (*port_manager_->outputs())[port_index]->Send(data);
   // |client| will be checked inside MidiManager::AccumulateMidiBytesSent.
-  PostReplyTask(
-      base::Bind(&DynamicallyInitializedMidiManagerWin::AccumulateMidiBytesSent,
-                 base::Unretained(this), client, data.size()));
+  PostReplyTask(base::Bind(&MidiManagerWin::AccumulateMidiBytesSent,
+                           base::Unretained(this), client, data.size()));
 }
 
 MidiManager* MidiManager::Create(MidiService* service) {
   if (base::FeatureList::IsEnabled(features::kMidiManagerWinrt) &&
-      base::win::GetVersion() >= base::win::VERSION_WIN10)
+      base::win::GetVersion() >= base::win::VERSION_WIN10) {
     return new MidiManagerWinrt(service);
-  return new DynamicallyInitializedMidiManagerWin(service);
+  }
+  return new MidiManagerWin(service);
 }
 
 }  // namespace midi