Check if null pointer is provided in DeviceWatcher callbacks

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"
 
 #pragma warning(disable : 4467)
 
 #include <initguid.h>  // Required by <devpkey.h>
 
@@ skipping 384 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) {
+              if (!info) {
+                VLOG(1) << "DeviceWatcher.Added callback provides null "
+                           "pointer, ignoring";
+                return S_OK;
+              }
+
               // 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,
@@ skipping 24 matching lines @@
     if (FAILED(hr)) {
       VLOG(1) << "add_EnumerationCompleted failed: " << PrintHr(hr);
       return false;
     }
 
     hr = watcher_->add_Removed(
         WRL::Callback<
             ITypedEventHandler<DeviceWatcher*, DeviceInformationUpdate*>>(
             [weak_ptr, task_runner](IDeviceWatcher* watcher,
                                     IDeviceInformationUpdate* update) {
+              if (!update) {
+                VLOG(1) << "DeviceWatcher.Removed callback provides null "
+                           "pointer, ignoring";
+                return S_OK;
+              }
+
               std::string dev_id = GetIdString(update);
 
               task_runner->PostTask(
                   FROM_HERE,
                   base::Bind(&MidiPortManager::OnRemoved, weak_ptr, dev_id));
 
               return S_OK;
             })
             .Get(),
         &token_Removed_);
@@ skipping 130 matching lines @@
       return;
     }
 
     base::WeakPtr<MidiPortManager> weak_ptr = GetWeakPtrFromFactory();
     scoped_refptr<base::SingleThreadTaskRunner> task_runner = task_runner_;
 
     hr = async_op->put_Completed(
         WRL::Callback<IAsyncOperationCompletedHandler<RuntimeType*>>(
             [weak_ptr, task_runner](IAsyncOperation<RuntimeType*>* async_op,
                                     AsyncStatus status) {
-              InterfaceType* handle;
-              HRESULT hr = async_op->GetResults(&handle);
-              if (FAILED(hr)) {
-                VLOG(1) << "GetResults failed: " << PrintHr(hr);
-                return hr;
-              }
-
               // A reference to |async_op| is kept in |async_ops_|, safe to pass
               // outside.
               task_runner->PostTask(
                   FROM_HERE,
                   base::Bind(&MidiPortManager::OnCompletedGetPortFromIdAsync,
-                             weak_ptr, handle, async_op));
+                             weak_ptr, async_op));
 
               return S_OK;
             })
             .Get());
     if (FAILED(hr)) {
       VLOG(1) << "put_Completed failed: " << PrintHr(hr);
       return;
     }
 
     // Keep a reference to incompleted |async_op| for releasing later.
@@ skipping 21 matching lines @@
       VLOG(1) << "Removing non-existent port " << dev_id;
       return;
     }
 
     SetPortState(port->index, MIDI_PORT_DISCONNECTED);
 
     RemovePortEventHandlers(port);
     port->handle = nullptr;
   }
 
-  void OnCompletedGetPortFromIdAsync(InterfaceType* handle,
-                                     IAsyncOperation<RuntimeType*>* async_op) {
+  void OnCompletedGetPortFromIdAsync(IAsyncOperation<RuntimeType*>* async_op) {
     DCHECK(thread_checker_.CalledOnValidThread());
     CHECK(is_initialized_);
 
+    InterfaceType* handle = nullptr;
+    HRESULT hr = async_op->GetResults(&handle);
+    if (FAILED(hr)) {
+      VLOG(1) << "GetResults failed: " << PrintHr(hr);
+      return;
+    }
+
+    // Manually release COM interface to completed |async_op|.
+    auto it = async_ops_.find(async_op);
+    CHECK(it != async_ops_.end());
+    (*it)->Release();
+    async_ops_.erase(it);
+
+    if (!handle) {
+      VLOG(1) << "Midi{In,Out}Port.FromIdAsync callback provides null pointer, "
+                 "ignoring";
+      return;
+    }
+
     EventRegistrationToken token = {kInvalidTokenValue};
     if (!RegisterOnMessageReceived(handle, &token))
       return;
 
     std::string dev_id = GetDeviceIdString(handle);
 
     MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
 
     if (port == nullptr) {
       std::string manufacturer = "Unknown", driver_version = "Unknown";
       GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version);
 
       AddPort(MidiPortInfo(dev_id, manufacturer, port_names_[dev_id],
                            driver_version, MIDI_PORT_OPENED));
 
       port = new MidiPort<InterfaceType>;
       port->index = static_cast<uint32_t>(port_ids_.size());
 
       ports_[dev_id].reset(port);
       port_ids_.push_back(dev_id);
     } else {
       SetPortState(port->index, MIDI_PORT_CONNECTED);
     }
 
     port->handle = handle;
     port->token_MessageReceived = token;
 
-    // Manually release COM interface to completed |async_op|.
-    auto it = async_ops_.find(async_op);
-    CHECK(it != async_ops_.end());
-    (*it)->Release();
-    async_ops_.erase(it);
-
     if (enumeration_completed_not_ready_ && async_ops_.empty()) {
       midi_manager_->OnPortManagerReady();
       enumeration_completed_not_ready_ = false;
     }
   }
 
   // Overrided by MidiInPortManager to listen to input ports.
   virtual bool RegisterOnMessageReceived(InterfaceType* handle,
                                          EventRegistrationToken* p_token) {
     return true;
@@ skipping 322 matching lines @@
 void MidiManagerWinrt::OnPortManagerReady() {
   DCHECK(com_thread_checker_->CalledOnValidThread());
   DCHECK(port_manager_ready_count_ < 2);
 
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
 }  // namespace midi
 }  // namespace media