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

media/audio/win/audio_low_latency_output_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/audio/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include <climits>
 
@@ skipping 113 matching lines @@
 WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
 }
 
 bool WASAPIAudioOutputStream::Open() {
   DVLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
     return true;
 
-  DCHECK(!audio_client_.get());
-  DCHECK(!audio_render_client_.get());
+  DCHECK(!audio_client_.Get());
+  DCHECK(!audio_render_client_.Get());
 
   // Will be set to true if we ended up opening the default communications
   // device.
   bool communications_device = false;
 
   // Create an IAudioClient interface for the default rendering IMMDevice.
   ScopedComPtr<IAudioClient> audio_client;
   if (device_id_.empty()) {
     audio_client = CoreAudioUtil::CreateDefaultClient(eRender, device_role_);
     communications_device = (device_role_ == eCommunications);
   } else {
     ScopedComPtr<IMMDevice> device(CoreAudioUtil::CreateDevice(device_id_));
-    DLOG_IF(ERROR, !device.get()) << "Failed to open device: " << device_id_;
-    if (device.get())
-      audio_client = CoreAudioUtil::CreateClient(device.get());
+    DLOG_IF(ERROR, !device.Get()) << "Failed to open device: " << device_id_;
+    if (device.Get())
+      audio_client = CoreAudioUtil::CreateClient(device.Get());
   }
 
-  if (!audio_client.get())
+  if (!audio_client.Get())
     return false;
 
   // Extra sanity to ensure that the provided device format is still valid.
-  if (!CoreAudioUtil::IsFormatSupported(audio_client.get(), share_mode_,
+  if (!CoreAudioUtil::IsFormatSupported(audio_client.Get(), share_mode_,
                                         &format_)) {
     LOG(ERROR) << "Audio parameters are not supported.";
     return false;
   }
 
   HRESULT hr = S_FALSE;
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     // Initialize the audio stream between the client and the device in shared
     // mode and using event-driven buffer handling.
     hr = CoreAudioUtil::SharedModeInitialize(
-        audio_client.get(), &format_, audio_samples_render_event_.Get(),
+        audio_client.Get(), &format_, audio_samples_render_event_.Get(),
         &endpoint_buffer_size_frames_,
         communications_device ? &kCommunicationsSessionId : NULL);
     if (FAILED(hr))
       return false;
 
     REFERENCE_TIME device_period = 0;
     if (FAILED(CoreAudioUtil::GetDevicePeriod(
-            audio_client.get(), AUDCLNT_SHAREMODE_SHARED, &device_period))) {
+            audio_client.Get(), AUDCLNT_SHAREMODE_SHARED, &device_period))) {
       return false;
     }
 
     const int preferred_frames_per_buffer = static_cast<int>(
         format_.Format.nSamplesPerSec *
             CoreAudioUtil::RefererenceTimeToTimeDelta(device_period)
                 .InSecondsF() +
         0.5);
 
     // Packet size should always be an even divisor of the device period for
@@ skipping 19 matching lines @@
       LOG(WARNING)
           << "Using WASAPI output with a non-optimal buffer size, glitches from"
           << " back to back shared memory reads and partial fills of WASAPI"
           << " output buffers may occur.  Buffer size of "
           << packet_size_frames_ << " is not an even divisor of "
           << preferred_frames_per_buffer;
     }
   } else {
     // TODO(henrika): break out to CoreAudioUtil::ExclusiveModeInitialize()
     // when removing the enable-exclusive-audio flag.
-    hr = ExclusiveModeInitialization(audio_client.get(),
+    hr = ExclusiveModeInitialization(audio_client.Get(),
                                      audio_samples_render_event_.Get(),
                                      &endpoint_buffer_size_frames_);
     if (FAILED(hr))
       return false;
 
     // The buffer scheme for exclusive mode streams is not designed for max
     // flexibility. We only allow a "perfect match" between the packet size set
     // by the user and the actual endpoint buffer size.
     if (endpoint_buffer_size_frames_ != packet_size_frames_) {
       LOG(ERROR) << "Bailing out due to non-perfect timing.";
       return false;
     }
   }
 
   // Create an IAudioRenderClient client for an initialized IAudioClient.
   // The IAudioRenderClient interface enables us to write output data to
   // a rendering endpoint buffer.
   ScopedComPtr<IAudioRenderClient> audio_render_client =
-      CoreAudioUtil::CreateRenderClient(audio_client.get());
-  if (!audio_render_client.get())
+      CoreAudioUtil::CreateRenderClient(audio_client.Get());
+  if (!audio_render_client.Get())
     return false;
 
   // Store valid COM interfaces.
   audio_client_ = audio_client;
   audio_render_client_ = audio_render_client;
 
   hr = audio_client_->GetService(__uuidof(IAudioClock),
                                  audio_clock_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get IAudioClock service.";
@@ skipping 13 matching lines @@
   if (render_thread_) {
     CHECK_EQ(callback, source_);
     return;
   }
 
   source_ = callback;
 
   // Ensure that the endpoint buffer is prepared with silence.
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     if (!CoreAudioUtil::FillRenderEndpointBufferWithSilence(
-            audio_client_.get(), audio_render_client_.get())) {
+            audio_client_.Get(), audio_render_client_.Get())) {
       LOG(ERROR) << "Failed to prepare endpoint buffers with silence.";
       callback->OnError(this);
       return;
     }
   }
   num_written_frames_ = endpoint_buffer_size_frames_;
 
   // Create and start the thread that will drive the rendering by waiting for
   // render events.
   render_thread_.reset(new base::DelegateSimpleThread(
@@ skipping 368 matching lines @@
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media