Disable Microsoft GS Wavetable Synth in Windows 10 Web MIDI backend

media/midi/midi_manager_winrt.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 "media/midi/midi_manager_winrt.h"
 
 #include <comdef.h>
 #include <robuffer.h>
 #include <windows.devices.enumeration.h>
 #include <windows.devices.midi.h>
@@ skipping 100 matching lines @@
   // Lifetime of the pointing buffer is controlled by the buffer object.
   hr = buffer_byte_access->Buffer(out);
   if (FAILED(hr)) {
     VLOG(1) << "Buffer failed: " << PrintHr(hr);
     return hr;
   }
 
   return S_OK;
 }
 
+// Checks if given DeviceInformation represent a Microsoft GS Wavetable Synth
+// instance.
+bool IsMicrosoftSynthesizer(IDeviceInformation* info) {
+  auto midi_synthesizer_statics =
+      WrlStaticsFactory<IMidiSynthesizerStatics,
+                        RuntimeClass_Windows_Devices_Midi_MidiSynthesizer>();
+  boolean result = false;
+  HRESULT hr = midi_synthesizer_statics->IsSynthesizer(info, &result);
+  VLOG_IF(1, FAILED(hr)) << "IsSynthesizer failed: " << PrintHr(hr);
+  return result != 0;

[Takashi Toyoshima, 2016/08/31 07:10:21]

|result| is bool from the beginning, right?

[Shao-Chuan Lee, 2016/08/31 07:16:51]

'boolean' is actually unsigned char, casting it to bool with '!= 0' here.

[Takashi Toyoshima, 2016/08/31 07:30:00]

Wow, it isn't standard bool. OK, so as we discussed offline, let's initialize it
with FALSE so that we can easily notice that it's MS specific type, and
probably, it's better in terms of removing implicit cast.

[Shao-Chuan Lee, 2016/08/31 07:42:49]

Done.
https://msdn.microsoft.com/en-us/library/windows/desktop/aa366740(v=vs.85).aspx

+}
+
 // Tokens with value = 0 are considered invalid (as in <wrl/event.h>).
 const int64_t kInvalidTokenValue = 0;
 
 template <typename InterfaceType>
 struct MidiPort {
   MidiPort() = default;
 
   uint32_t index;
   ScopedComPtr<InterfaceType> handle;
   EventRegistrationToken token_MessageReceived;
@@ skipping 51 matching lines @@
     // thread. |weak_ptr| and |task_runner| are captured by lambda callbacks for
     // posting jobs. Note that WinRT callback arguments should not be passed
     // outside the callback since the pointers may be unavailable afterwards.
     base::WeakPtr<MidiPortManager> weak_ptr = GetWeakPtrFromFactory();
     scoped_refptr<base::SingleThreadTaskRunner> task_runner = task_runner_;
 
     hr = watcher_->add_Added(
         WRL::Callback<ITypedEventHandler<DeviceWatcher*, DeviceInformation*>>(
             [weak_ptr, task_runner](IDeviceWatcher* watcher,
                                     IDeviceInformation* info) {
+              // Disable Microsoft GS Wavetable Synth due to security reasons.
+              // http://crbug.com/499279
+              if (IsMicrosoftSynthesizer(info))
+                return S_OK;
+
               std::string dev_id = GetIdString(info),
                           dev_name = GetNameString(info);
 
               task_runner->PostTask(
                   FROM_HERE, base::Bind(&MidiPortManager::OnAdded, weak_ptr,
                                         dev_id, dev_name));
 
               return S_OK;
             })
             .Get(),
@@ skipping 147 matching lines @@
 
   // Ensures all methods are called on the COM thread.
   base::ThreadChecker thread_checker_;
 
  private:
   // DeviceWatcher callbacks:
   void OnAdded(std::string dev_id, std::string dev_name) {
     DCHECK(thread_checker_.CalledOnValidThread());
     CHECK(is_initialized_);
 
-    // TODO(shaochuan): Disable Microsoft GS Wavetable Synth due to security
-    // reasons. http://crbug.com/499279
-
     port_names_[dev_id] = dev_name;
 
     WRL::Wrappers::HString dev_id_hstring;
     HRESULT hr = dev_id_hstring.Set(base::UTF8ToWide(dev_id).c_str());
     if (FAILED(hr)) {
       VLOG(1) << "Set failed: " << PrintHr(hr);
       return;
     }
 
     IAsyncOperation<RuntimeType*>* async_op;
@@ skipping 44 matching lines @@
     if (async_ops_.empty())
       midi_manager_->OnPortManagerReady();
     else
       enumeration_completed_not_ready_ = true;
   }
 
   void OnRemoved(std::string dev_id) {
     DCHECK(thread_checker_.CalledOnValidThread());
     CHECK(is_initialized_);
 
+    // Note: in case Microsoft GS Wavetable Synth triggers this event for some
+    // reason, it will be ignored here with log emitted.
     MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
     if (!port) {
       VLOG(1) << "Removing non-existent port " << dev_id;
       return;
     }
 
     SetPortState(port->index, MIDI_PORT_DISCONNECTED);
 
     RemovePortEventHandlers(port);
     port->handle = nullptr;
@@ skipping 58 matching lines @@
   virtual void SetPortState(uint32_t port_index, MidiPortState state) = 0;
 
   // WeakPtrFactory has to be declared in derived class, use this method to
   // retrieve upcasted WeakPtr for posting tasks.
   virtual base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() = 0;
 
   // Midi{In,Out}PortStatics instance.
   ScopedComPtr<StaticsInterfaceType> midi_port_statics_;
 
   // DeviceWatcher instance and event registration tokens for unsubscribing
   // events in destructor.

[Shao-Chuan Lee, 2016/08/31 06:55:28]

Should be StopWatcher() instead of destructor.
May I fix it here? This seems too small to have a separate CL..

[Takashi Toyoshima, 2016/08/31 07:10:21]

OK, let's fix this in a separate CL.

   ScopedComPtr<IDeviceWatcher> watcher_;
   EventRegistrationToken token_Added_ = {kInvalidTokenValue},
                          token_EnumerationCompleted_ = {kInvalidTokenValue},
                          token_Removed_ = {kInvalidTokenValue},
                          token_Stopped_ = {kInvalidTokenValue},
                          token_Updated_ = {kInvalidTokenValue};
 
   // All manipulations to these fields should be done on COM thread.
   std::unordered_map<std::string, std::unique_ptr<MidiPort<InterfaceType>>>
       ports_;
@@ skipping 290 matching lines @@
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerWinrt();
 }
 
 }  // namespace midi
 }  // namespace media