Rename ScopedComPtr::get() to ScopedComPtr::Get()

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 <algorithm>
@@ skipping 114 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());
-  if (pin_enum.get() == NULL)
+  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) {
     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)) &&
+      if ((category == GUID_NULL || PinMatchesCategory(pin.Get(), category)) &&
           (major_type == GUID_NULL ||
-           PinMatchesMajorType(pin.get(), major_type))) {
+           PinMatchesMajorType(pin.Get(), major_type))) {
         return pin;
       }
     }
     pin.Reset();
   }
 
-  DCHECK(!pin.get());
+  DCHECK(!pin.Get());
   return pin;
 }
 
 // static
 VideoPixelFormat
 VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
     const GUID& sub_type) {
   static struct {
     const GUID& sub_type;
     VideoPixelFormat format;
@@ skipping 63 matching lines @@
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(
     const VideoCaptureDeviceDescriptor& device_descriptor)
     : device_descriptor_(device_descriptor), state_(kIdle) {
   // TODO(mcasas): Check that CoInitializeEx() has been called with the
   // appropriate Apartment model, i.e., Single Threaded.
 }
 
 VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (media_control_.get())
+  if (media_control_.Get())
     media_control_->Stop();
 
-  if (graph_builder_.get()) {
+  if (graph_builder_.Get()) {
     if (sink_filter_.get()) {
       graph_builder_->RemoveFilter(sink_filter_.get());
       sink_filter_ = NULL;
     }
 
-    if (capture_filter_.get())
-      graph_builder_->RemoveFilter(capture_filter_.get());
+    if (capture_filter_.Get())
+      graph_builder_->RemoveFilter(capture_filter_.Get());
   }
 
-  if (capture_graph_builder_.get())
+  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());
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
-  if (!capture_filter_.get())
+  if (!capture_filter_.Get())
     return false;
 
-  output_capture_pin_ = GetPin(capture_filter_.get(), PINDIR_OUTPUT,
+  output_capture_pin_ = GetPin(capture_filter_.Get(), PINDIR_OUTPUT,
                                PIN_CATEGORY_CAPTURE, GUID_NULL);
-  if (!output_capture_pin_.get()) {
+  if (!output_capture_pin_.Get()) {
     DLOG(ERROR) << "Failed to get capture output pin";
     return false;
   }
 
   // Create the sink filter used for receiving Captured frames.
   sink_filter_ = new SinkFilter(this);
   if (sink_filter_.get() == NULL) {
     DLOG(ERROR) << "Failed to create sink filter";
     return false;
   }
 
   input_sink_pin_ = sink_filter_->GetPin(0);
 
   hr = graph_builder_.CreateInstance(CLSID_FilterGraph, NULL,
                                      CLSCTX_INPROC_SERVER);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
   if (FAILED(hr))
     return false;
 
   hr = capture_graph_builder_.CreateInstance(CLSID_CaptureGraphBuilder2, NULL,
                                              CLSCTX_INPROC);
   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());
+  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());
   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);
+  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(),
+      &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, capture_filter_.Get(),
       IID_IAMStreamConfig, (void**)stream_config.Receive());
   if (FAILED(hr)) {
     hr = capture_graph_builder_->FindInterface(
-        &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, capture_filter_.get(),
+        &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, capture_filter_.Get(),
         IID_IAMStreamConfig, (void**)stream_config.Receive());
     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) {
@@ skipping 54 matching lines @@
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to set capture device output format", hr);
     return;
   }
 
   SetAntiFlickerInCaptureFilter(params);
 
   if (media_type->subtype == kMediaSubTypeHDYC) {
     // HDYC pixel format, used by the DeckLink capture card, needs an AVI
     // decompressor filter after source, let |graph_builder_| add it.
-    hr = graph_builder_->Connect(output_capture_pin_.get(),
-                                 input_sink_pin_.get());
+    hr = graph_builder_->Connect(output_capture_pin_.Get(),
+                                 input_sink_pin_.Get());
   } else {
-    hr = graph_builder_->ConnectDirect(output_capture_pin_.get(),
-                                       input_sink_pin_.get(), NULL);
+    hr = graph_builder_->ConnectDirect(output_capture_pin_.Get(),
+                                       input_sink_pin_.Get(), NULL);
   }
 
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to connect the Capture graph.", hr);
     return;
   }
 
   hr = media_control_->Pause();
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to pause the Capture device", hr);
@@ skipping 15 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kCapturing)
     return;
 
   HRESULT hr = media_control_->Stop();
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to stop the capture graph.", hr);
     return;
   }
 
-  graph_builder_->Disconnect(output_capture_pin_.get());
-  graph_builder_->Disconnect(input_sink_pin_.get());
+  graph_builder_->Disconnect(output_capture_pin_.Get());
+  graph_builder_->Disconnect(input_sink_pin_.Get());
 
   client_.reset();
   state_ = kIdle;
 }
 
 void VideoCaptureDeviceWin::TakePhoto(TakePhotoCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // DirectShow has other means of capturing still pictures, e.g. connecting a
   // SampleGrabber filter to a PIN_CATEGORY_STILL of |capture_filter_|. This
   // way, however, is not widespread and proves too cumbersome, so we just grab
@@ skipping 66 matching lines @@
       if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
         continue;
 
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
       format.frame_size.SetSize(h->bmiHeader.biWidth, h->bmiHeader.biHeight);
 
       // Try to get a better |time_per_frame| from IAMVideoControl. If not, use
       // the value from VIDEOINFOHEADER.
       REFERENCE_TIME time_per_frame = h->AvgTimePerFrame;
-      if (video_control.get()) {
+      if (video_control.Get()) {
         ScopedCoMem<LONGLONG> max_fps;
         LONG list_size = 0;
         const SIZE size = {format.frame_size.width(),
                            format.frame_size.height()};
-        hr = video_control->GetFrameRateList(output_capture_pin_.get(),
+        hr = video_control->GetFrameRateList(output_capture_pin_.Get(),
                                              stream_index, size, &list_size,
                                              &max_fps);
         // Can't assume the first value will return the max fps.
         // Sometimes |list_size| will be > 0, but max_fps will be NULL. Some
         // drivers may return an HRESULT of S_FALSE which SUCCEEDED() translates
         // into success, so explicitly check S_OK. See http://crbug.com/306237.
         if (hr == S_OK && list_size > 0 && max_fps) {
           time_per_frame =
               *std::min_element(max_fps.get(), max_fps.get() + list_size);
         }
@@ skipping 15 matching lines @@
 void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter(
     const VideoCaptureParams& params) {
   const PowerLineFrequency power_line_frequency = GetPowerLineFrequency(params);
   if (power_line_frequency != media::PowerLineFrequency::FREQUENCY_50HZ &&
       power_line_frequency != media::PowerLineFrequency::FREQUENCY_60HZ) {
     return;
   }
   ScopedComPtr<IKsPropertySet> ks_propset;
   DWORD type_support = 0;
   HRESULT hr;
-  if (SUCCEEDED(hr = ks_propset.QueryFrom(capture_filter_.get())) &&
+  if (SUCCEEDED(hr = ks_propset.QueryFrom(capture_filter_.Get())) &&
       SUCCEEDED(hr = ks_propset->QuerySupported(
                     PROPSETID_VIDCAP_VIDEOPROCAMP,
                     KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY,
                     &type_support)) &&
       (type_support & KSPROPERTY_SUPPORT_SET)) {
     KSPROPERTY_VIDEOPROCAMP_S data = {};
     data.Property.Set = PROPSETID_VIDCAP_VIDEOPROCAMP;
     data.Property.Id = KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY;
     data.Property.Flags = KSPROPERTY_TYPE_SET;
     data.Value =
@@ skipping 10 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