Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

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>
 #include <vidcap.h>
@@ skipping 98 matching lines @@
   DCHECK(filter);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr =
       dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC);
   if (FAILED(hr))
     return hr;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
-                                       enum_moniker.Receive(), 0);
+                                       enum_moniker.GetAddressOf(), 0);
   // CreateClassEnumerator returns S_FALSE on some Windows OS
   // when no camera exist. Therefore the FAILED macro can't be used.
   if (hr != S_OK)
     return hr;
 
   ScopedComPtr<IBaseFilter> capture_filter;
   for (ScopedComPtr<IMoniker> moniker;
-       enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK;
+       enum_moniker->Next(1, moniker.GetAddressOf(), NULL) == S_OK;
        moniker.Reset()) {
     ScopedComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
     if (FAILED(hr))
       continue;
 
     // Find |device_id| via DevicePath, Description or FriendlyName, whichever
     // is available first and is a VT_BSTR (i.e. String) type.
     static const wchar_t* kPropertyNames[] = {L"DevicePath", L"Description",
                                               L"FriendlyName"};
@@ skipping 26 matching lines @@
 
 // Finds an IPin on an IBaseFilter given the direction, Category and/or Major
 // Type. If either |category| or |major_type| are GUID_NULL, they are ignored.
 // static
 ScopedComPtr<IPin> VideoCaptureDeviceWin::GetPin(IBaseFilter* filter,
                                                  PIN_DIRECTION pin_dir,
                                                  REFGUID category,
                                                  REFGUID major_type) {
   ScopedComPtr<IPin> pin;
   ScopedComPtr<IEnumPins> pin_enum;
-  HRESULT hr = filter->EnumPins(pin_enum.Receive());
+  HRESULT hr = filter->EnumPins(pin_enum.GetAddressOf());
   if (pin_enum.Get() == NULL)
     return pin;
 
   // Get first unconnected pin.
   hr = pin_enum->Reset();  // set to first pin
-  while ((hr = pin_enum->Next(1, pin.Receive(), NULL)) == S_OK) {
+  while ((hr = pin_enum->Next(1, pin.GetAddressOf(), NULL)) == S_OK) {
     PIN_DIRECTION this_pin_dir = static_cast<PIN_DIRECTION>(-1);
     hr = pin->QueryDirection(&this_pin_dir);
     if (pin_dir == this_pin_dir) {
       if ((category == GUID_NULL || PinMatchesCategory(pin.Get(), category)) &&
           (major_type == GUID_NULL ||
            PinMatchesMajorType(pin.Get(), major_type))) {
         return pin;
       }
     }
     pin.Reset();
@@ skipping 96 matching lines @@
   }
 
   if (capture_graph_builder_.Get())
     capture_graph_builder_.Reset();
 }
 
 bool VideoCaptureDeviceWin::Init() {
   DCHECK(thread_checker_.CalledOnValidThread());
   HRESULT hr;
 
-  hr = GetDeviceFilter(device_descriptor_.device_id, capture_filter_.Receive());
+  hr = GetDeviceFilter(device_descriptor_.device_id,
+                       capture_filter_.GetAddressOf());
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
   if (!capture_filter_.Get())
     return false;
 
   output_capture_pin_ = GetPin(capture_filter_.Get(), PINDIR_OUTPUT,
                                PIN_CATEGORY_CAPTURE, GUID_NULL);
   if (!output_capture_pin_.Get()) {
     DLOG(ERROR) << "Failed to get capture output pin";
     return false;
   }
@@ skipping 18 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_.CopyTo(media_control_.Receive());
+  hr = graph_builder_.CopyTo(media_control_.GetAddressOf());
   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;
 
   hr = graph_builder_->AddFilter(sink_filter_.get(), NULL);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to add the sink filter to the graph", hr);
   if (FAILED(hr))
     return false;
 
   // The following code builds the upstream portions of the graph, for example
   // if a capture device uses a Windows Driver Model (WDM) driver, the graph may
   // require certain filters upstream from the WDM Video Capture filter, such as
   // a TV Tuner filter or an Analog Video Crossbar filter. We try using the more
   // prevalent MEDIATYPE_Interleaved first.
   base::win::ScopedComPtr<IAMStreamConfig> stream_config;
 
   hr = capture_graph_builder_->FindInterface(
       &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, capture_filter_.Get(),
-      IID_IAMStreamConfig, (void**)stream_config.Receive());
+      IID_IAMStreamConfig, (void**)stream_config.GetAddressOf());
   if (FAILED(hr)) {
     hr = capture_graph_builder_->FindInterface(
         &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, capture_filter_.Get(),
-        IID_IAMStreamConfig, (void**)stream_config.Receive());
+        IID_IAMStreamConfig, (void**)stream_config.GetAddressOf());
     DLOG_IF_FAILED_WITH_HRESULT("Failed to find CapFilter:IAMStreamConfig", hr);
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   client_ = std::move(client);
 
   // Get the camera capability that best match the requested format.
   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_.CopyTo(stream_config.Receive());
+  HRESULT hr = output_capture_pin_.CopyTo(stream_config.GetAddressOf());
   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 87 matching lines @@
   // way, however, is not widespread and proves too cumbersome, so we just grab
   // the next captured frame instead.
   take_photo_callbacks_.push(std::move(callback));
 }
 
 void VideoCaptureDeviceWin::GetPhotoCapabilities(
     GetPhotoCapabilitiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::win::ScopedComPtr<IKsTopologyInfo> info;
-  HRESULT hr = capture_filter_.CopyTo(info.Receive());
+  HRESULT hr = capture_filter_.CopyTo(info.GetAddressOf());
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to obtain the topology info.", hr);
     return;
   }
 
   DWORD num_nodes = 0;
   hr = info->get_NumNodes(&num_nodes);
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to obtain the number of nodes.", hr);
     return;
   }
 
   // Every UVC camera is expected to have a single ICameraControl and a single
   // IVideoProcAmp nodes, and both are needed; ignore any unlikely later ones.
   GUID node_type;
   base::win::ScopedComPtr<ICameraControl> camera_control;
   for (size_t i = 0; i < num_nodes; i++) {
     info->get_NodeType(i, &node_type);
     if (IsEqualGUID(node_type, KSNODETYPE_VIDEO_CAMERA_TERMINAL)) {
-      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(camera_control.Receive()));
+      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(&camera_control));
       if (SUCCEEDED(hr))
         break;
       SetErrorState(FROM_HERE, "Failed to retrieve the ICameraControl.", hr);
       return;
     }
   }
   if (!camera_control)
     return;
   base::win::ScopedComPtr<IVideoProcAmp> video_control;
   for (size_t i = 0; i < num_nodes; i++) {
     info->get_NodeType(i, &node_type);
     if (IsEqualGUID(node_type, KSNODETYPE_VIDEO_PROCESSING)) {
-      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(video_control.Receive()));
+      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(&video_control));
       if (SUCCEEDED(hr))
         break;
       SetErrorState(FROM_HERE, "Failed to retrieve the IVideoProcAmp.", hr);
       return;
     }
   }
   if (!video_control)
     return;
 
   auto photo_capabilities = mojom::PhotoCapabilities::New();
@@ skipping 98 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_.CopyTo(stream_config.Receive());
+  HRESULT hr = output_capture_pin_.CopyTo(stream_config.GetAddressOf());
   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_.CopyTo(video_control.Receive());
+  hr = capture_filter_.CopyTo(video_control.GetAddressOf());
 
   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