Change sync primitives ownership for audio rendering.

content/browser/renderer_host/media/audio_sync_reader.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 "content/browser/renderer_host/media/audio_sync_reader.h"
 
 #include <algorithm>
+#include <string>
+#include <utility>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/audio_parameters.h"
 
 using media::AudioBus;
@@ skipping 12 matching lines @@
 void LogAudioGlitchResult(AudioGlitchResult result) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioRendererAudioGlitches",
                             result,
                             AUDIO_RENDERER_AUDIO_GLITCHES_MAX + 1);
 }
 
 }  // namespace
 
 namespace content {
 
-AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory,
-                                 const media::AudioParameters& params)
-    : shared_memory_(shared_memory),
+AudioSyncReader::AudioSyncReader(
+    const media::AudioParameters& params,
+    std::unique_ptr<base::SharedMemory> shared_memory,
+    std::unique_ptr<base::CancelableSyncSocket> socket,
+    std::unique_ptr<base::CancelableSyncSocket> foreign_socket)
+    : shared_memory_(std::move(shared_memory)),
       mute_audio_(base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMuteAudio)),
+      socket_(std::move(socket)),
+      foreign_socket_(std::move(foreign_socket)),
       packet_size_(shared_memory_->requested_size()),
       renderer_callback_count_(0),
       renderer_missed_callback_count_(0),
       trailing_renderer_missed_callback_count_(0),
 #if defined(OS_MACOSX)
       maximum_wait_time_(params.GetBufferDuration() / 2),
 #else
       // TODO(dalecurtis): Investigate if we can reduce this on all platforms.
       maximum_wait_time_(base::TimeDelta::FromMilliseconds(20)),
 #endif
@@ skipping 42 matching lines @@
   renderer_missed_callback_count_ > 0 ?
       LogAudioGlitchResult(AUDIO_RENDERER_AUDIO_GLITCHES) :
       LogAudioGlitchResult(AUDIO_RENDERER_NO_AUDIO_GLITCHES);
   std::string log_string = base::StringPrintf(
       "ASR: number of detected audio glitches: %" PRIuS " out of %" PRIuS,
       renderer_missed_callback_count_, renderer_callback_count_);
   MediaStreamManager::SendMessageToNativeLog(log_string);
   DVLOG(1) << log_string;
 }
 
+// static
+std::unique_ptr<AudioSyncReader> AudioSyncReader::Create(
+    const media::AudioParameters& params) {
+  base::CheckedNumeric<size_t> memory_size =
+      sizeof(media::AudioOutputBufferParameters);
+  memory_size += AudioBus::CalculateMemorySize(params);
+
+  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
+  std::unique_ptr<base::CancelableSyncSocket> socket(
+      new base::CancelableSyncSocket());
+  std::unique_ptr<base::CancelableSyncSocket> foreign_socket(
+      new base::CancelableSyncSocket());
+
+  if (!memory_size.IsValid() ||
+      !shared_memory->CreateAndMapAnonymous(memory_size.ValueOrDie()) ||
+      !base::CancelableSyncSocket::CreatePair(socket.get(),
+                                              foreign_socket.get())) {
+    return nullptr;
+  }
+  return base::WrapUnique(new AudioSyncReader(params, std::move(shared_memory),
+                                              std::move(socket),
+                                              std::move(foreign_socket)));
+}
+
 // media::AudioOutputController::SyncReader implementations.
 void AudioSyncReader::UpdatePendingBytes(uint32_t bytes,
                                          uint32_t frames_skipped) {
   // Increase the number of skipped frames stored in shared memory. We don't
   // send it over the socket since sending more than 4 bytes might lead to being
   // descheduled. The reading side will zero it when consumed.
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
   buffer->params.frames_skipped += frames_skipped;
 
@@ skipping 25 matching lines @@
   if (mute_audio_)
     dest->Zero();
   else
     output_bus_->CopyTo(dest);
 }
 
 void AudioSyncReader::Close() {
   socket_->Close();
 }
 
-bool AudioSyncReader::Init() {
-  socket_.reset(new base::CancelableSyncSocket());
-  foreign_socket_.reset(new base::CancelableSyncSocket());
-  return base::CancelableSyncSocket::CreatePair(socket_.get(),
-                                                foreign_socket_.get());
-}
-
-bool AudioSyncReader::PrepareForeignSocket(
-    base::ProcessHandle process_handle,
-    base::SyncSocket::TransitDescriptor* descriptor) {
-  return foreign_socket_->PrepareTransitDescriptor(process_handle, descriptor);
-}
-
 bool AudioSyncReader::WaitUntilDataIsReady() {
   TRACE_EVENT0("audio", "AudioSyncReader::WaitUntilDataIsReady");
   base::TimeDelta timeout = maximum_wait_time_;
   const base::TimeTicks start_time = base::TimeTicks::Now();
   const base::TimeTicks finish_time = start_time + timeout;
 
   // Check if data is ready and if not, wait a reasonable amount of time for it.
   //
   // Data readiness is achieved via parallel counters, one on the renderer side
   // and one here.  Every time a buffer is requested via UpdatePendingBytes(),
@@ skipping 35 matching lines @@
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(1000),
                                50);
     return false;
   }
 
   return true;
 }
 
 }  // namespace content