Rename ScopedComPtr::QueryInterface to ScopedComPtr::CopyTo

media/capture/video/win/video_capture_device_win.cc

 // Copyright (c) 2012 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/capture/video/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 #include <objbase.h>
 
@@ skipping 276 matching lines @@
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create the Capture Graph Builder", hr);
   if (FAILED(hr))
     return false;
 
   hr = capture_graph_builder_->SetFiltergraph(graph_builder_.Get());
   DLOG_IF_FAILED_WITH_HRESULT("Failed to give graph to capture graph builder",
                               hr);
   if (FAILED(hr))
     return false;
 
-  hr = graph_builder_.QueryInterface(media_control_.Receive());
+  hr = graph_builder_.CopyTo(media_control_.Receive());
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create media control builder", hr);
   if (FAILED(hr))
     return false;
 
   hr = graph_builder_->AddFilter(capture_filter_.Get(), NULL);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to add the capture device to the graph",
                               hr);
   if (FAILED(hr))
     return false;
 
@@ skipping 35 matching lines @@
   const CapabilityWin found_capability =
       GetBestMatchedCapability(params.requested_format, capabilities_);
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
   const float frame_rate =
       std::min(params.requested_format.frame_rate,
                found_capability.supported_format.frame_rate);
 
   ScopedComPtr<IAMStreamConfig> stream_config;
-  HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
+  HRESULT hr = output_capture_pin_.CopyTo(stream_config.Receive());
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Can't get the Capture format settings", hr);
     return;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to GetNumberOfCapabilities", hr);
     return;
@@ skipping 111 matching lines @@
 
     mojom::BlobPtr blob = Blobify(buffer, length, format);
     if (blob)
       cb.Run(std::move(blob));
   }
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
-  HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
+  HRESULT hr = output_capture_pin_.CopyTo(stream_config.Receive());
   DLOG_IF_FAILED_WITH_HRESULT(
       "Failed to get IAMStreamConfig from capture device", hr);
   if (FAILED(hr))
     return false;
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
-  hr = capture_filter_.QueryInterface(video_control.Receive());
+  hr = capture_filter_.CopyTo(video_control.Receive());
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to GetNumberOfCapabilities", hr);
   if (FAILED(hr))
     return false;
 
   std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   for (int stream_index = 0; stream_index < count; ++stream_index) {
     ScopedMediaType media_type;
@@ skipping 86 matching lines @@
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason,
     HRESULT hr) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DLOG_IF_FAILED_WITH_HRESULT(reason, hr);
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 }  // namespace media