Plumb audio focus support for spitzer clients.

content/browser/renderer_host/media/audio_renderer_host.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_renderer_host.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.h"
+#include "content/browser/media/media_web_contents_observer.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 141 matching lines @@
   base::SharedMemory* shared_memory() {
     return shared_memory_.get();
   }
 
   media::AudioOutputController::SyncReader* reader() const {
     return reader_.get();
   }
 
   bool playing() const { return playing_; }
   void set_playing(bool playing) { playing_ = playing; }
+  void update_last_pause_time() { last_pause_time_ = base::TimeTicks::Now(); }
+  base::TimeTicks last_pause_time() { return last_pause_time_; }
 
  private:
   // media::AudioOutputController::EventHandler implementation.
   void OnCreated() override;
   void OnPlaying() override;
   void OnPaused() override;
   void OnError() override;
 
   AudioRendererHost* const host_;
   const int stream_id_;
 
   // The routing ID of the source RenderFrame.
   const int render_frame_id_;
 
   // Shared memory for transmission of the audio data.  Used by |reader_|.
   const scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The synchronous reader to be used by |controller_|.
   const scoped_ptr<media::AudioOutputController::SyncReader> reader_;
 
   // The AudioOutputController that manages the audio stream.
   const scoped_refptr<media::AudioOutputController> controller_;
 
   bool playing_;
+
+  base::TimeTicks last_pause_time_;
 };
 
 AudioRendererHost::AudioEntry::AudioEntry(
     AudioRendererHost* host,
     int stream_id,
     int render_frame_id,
     const media::AudioParameters& params,
     const std::string& output_device_id,
     scoped_ptr<base::SharedMemory> shared_memory,
     scoped_ptr<media::AudioOutputController::SyncReader> reader)
@@ skipping 411 matching lines @@
 
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
     return;
   }
 
+  if (entry->controller()->GetAudioParameters().effects() &
+      media::AudioParameters::FOCUSABLE) {
+    MediaWebContentsObserver::HasAudioFocus(
+        render_process_id_, entry->render_frame_id(),
+        base::Bind(&AudioRendererHost::OnFocusAvailable, this, stream_id,
+                   base::TimeTicks::Now()));
+  } else {
+    entry->controller()->Play();
+    audio_log_->OnStarted(stream_id);
+  }
+}
+
+void AudioRendererHost::OnFocusAvailable(int stream_id,
+                                         base::TimeTicks play_time) {
+  // Abort the playback if:
+  //   - The entry has been destroyed while focus was requested.
+  //   - A subsequent pause has come through.
+  //
+  // A focus request never fails via this path. If it's denied a pause request
+  // will be issues directly to the player.
+  AudioEntry* entry = LookupById(stream_id);
+  if (!entry || play_time < entry->last_pause_time())
+    return;
+
   entry->controller()->Play();
   audio_log_->OnStarted(stream_id);
 }
 
 void AudioRendererHost::OnPauseStream(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
     return;
   }
 
+  entry->update_last_pause_time();
   entry->controller()->Pause();
   audio_log_->OnStopped(stream_id);
 }
 
 void AudioRendererHost::OnSetVolume(int stream_id, double volume) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
@@ skipping 198 matching lines @@
   callback.Run(false, device_info);
 }
 
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const auto& i = authorizations_.find(stream_id);
   return i != authorizations_.end();
 }
 
 }  // namespace content