Cast: Don't create threads for each CastSessionDelegate

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_session_delegate.h"
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "chrome/renderer/media/cast_threads.h"
 #include "chrome/renderer/media/cast_transport_sender_ipc.h"
 #include "content/public/renderer/p2p_socket_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_sender.h"
 
 using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
 using media::cast::VideoSenderConfig;
 
+static base::LazyInstance<CastThreads> g_cast_threads =
+    LAZY_INSTANCE_INITIALIZER;
+
 CastSessionDelegate::CastSessionDelegate()
-    : audio_encode_thread_("CastAudioEncodeThread"),
-      video_encode_thread_("CastVideoEncodeThread"),
-      transport_configured_(false),
+    : transport_configured_(false),
       io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()) {
   DCHECK(io_message_loop_proxy_);
+  g_cast_threads.Get().IncrementUsage();

[scherkus (not reviewing), 2014/02/21 16:25:48]

do we ever create objects but not initialize them? this will create the threads
but potentially not use them until later

 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  g_cast_threads.Get().DecrementUsage();
 }
 
 void CastSessionDelegate::Initialize() {
   if (cast_environment_)
     return;  // Already initialized.
 
-  audio_encode_thread_.Start();
-  video_encode_thread_.Start();
-
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   // There's no need to decode so no thread assigned for decoding.
   // Get default logging: All disabled.
   cast_environment_ = new CastEnvironment(
       scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
       base::MessageLoopProxy::current(),
-      audio_encode_thread_.message_loop_proxy(),
+      g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
       NULL,
-      video_encode_thread_.message_loop_proxy(),
+      g_cast_threads.Get().GetVideoEncodeMessageLoopProxy(),
       NULL,
       base::MessageLoopProxy::current(),
       media::cast::GetDefaultCastSenderLoggingConfig());
 }
 
 void CastSessionDelegate::StartAudio(
     const AudioSenderConfig& config,
     const FrameInputAvailableCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 82 matching lines @@
   // TODO(pwestin): handle the error codes.
   if (result == media::cast::STATUS_INITIALIZED) {
     if (!audio_frame_input_available_callback_.is_null()) {
       audio_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
     if (!video_frame_input_available_callback_.is_null()) {
       video_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
   }
 }