src/media/cast/cast_environment.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/cast_environment.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10
  11 using base::SingleThreadTaskRunner;
  12
  13 namespace {
  14
  15 void DeleteLoggingOnMainThread(scoped_ptr<media::cast::LoggingImpl> logging) {
  16   logging.reset();
  17 }
  18
  19 }  // namespace
  20
  21 namespace media {
  22 namespace cast {
  23
  24 CastEnvironment::CastEnvironment(
  25     scoped_ptr<base::TickClock> clock,
  26     scoped_refptr<SingleThreadTaskRunner> main_thread_proxy,
  27     scoped_refptr<SingleThreadTaskRunner> audio_encode_thread_proxy,
  28     scoped_refptr<SingleThreadTaskRunner> audio_decode_thread_proxy,
  29     scoped_refptr<SingleThreadTaskRunner> video_encode_thread_proxy,
  30     scoped_refptr<SingleThreadTaskRunner> video_decode_thread_proxy,
  31     scoped_refptr<SingleThreadTaskRunner> transport_thread_proxy,
  32     const CastLoggingConfig& config)
  33     : clock_(clock.Pass()),
  34       main_thread_proxy_(main_thread_proxy),
  35       audio_encode_thread_proxy_(audio_encode_thread_proxy),
  36       audio_decode_thread_proxy_(audio_decode_thread_proxy),
  37       video_encode_thread_proxy_(video_encode_thread_proxy),
  38       video_decode_thread_proxy_(video_decode_thread_proxy),
  39       transport_thread_proxy_(transport_thread_proxy),
  40       logging_(new LoggingImpl(main_thread_proxy, config)) {
  41   DCHECK(main_thread_proxy);
  42 }
  43
  44 CastEnvironment::~CastEnvironment() {
  45   // Logging must be deleted on the main thread.
  46   if (main_thread_proxy_->RunsTasksOnCurrentThread()) {
  47     logging_.reset();
  48   } else {
  49     main_thread_proxy_->PostTask(
  50         FROM_HERE,
  51         base::Bind(&DeleteLoggingOnMainThread, base::Passed(&logging_)));
  52   }
  53 }
  54
  55 bool CastEnvironment::PostTask(ThreadId identifier,
  56                                const tracked_objects::Location& from_here,
  57                                const base::Closure& task) {
  58   scoped_refptr<SingleThreadTaskRunner> task_runner =
  59       GetMessageSingleThreadTaskRunnerForThread(identifier);
  60
  61   return task_runner->PostTask(from_here, task);
  62 }
  63
  64 bool CastEnvironment::PostDelayedTask(
  65     ThreadId identifier,
  66     const tracked_objects::Location& from_here,
  67     const base::Closure& task,
  68     base::TimeDelta delay) {
  69   scoped_refptr<SingleThreadTaskRunner> task_runner =
  70       GetMessageSingleThreadTaskRunnerForThread(identifier);
  71
  72   return task_runner->PostDelayedTask(from_here, task, delay);
  73 }
  74
  75 scoped_refptr<SingleThreadTaskRunner>
  76 CastEnvironment::GetMessageSingleThreadTaskRunnerForThread(
  77     ThreadId identifier) {
  78   switch (identifier) {
  79     case CastEnvironment::MAIN:
  80       return main_thread_proxy_;
  81     case CastEnvironment::AUDIO_ENCODER:
  82       return audio_encode_thread_proxy_;
  83     case CastEnvironment::AUDIO_DECODER:
  84       return audio_decode_thread_proxy_;
  85     case CastEnvironment::VIDEO_ENCODER:
  86       return video_encode_thread_proxy_;
  87     case CastEnvironment::VIDEO_DECODER:
  88       return video_decode_thread_proxy_;
  89     case CastEnvironment::TRANSPORT:
  90       return transport_thread_proxy_;
  91     default:
  92       NOTREACHED() << "Invalid Thread identifier";
  93       return NULL;
  94   }
  95 }
  96
  97 bool CastEnvironment::CurrentlyOn(ThreadId identifier) {
  98   switch (identifier) {
  99     case CastEnvironment::MAIN:
 100       return main_thread_proxy_->RunsTasksOnCurrentThread();
 101     case CastEnvironment::AUDIO_ENCODER:
 102       return audio_encode_thread_proxy_->RunsTasksOnCurrentThread();
 103     case CastEnvironment::AUDIO_DECODER:
 104       return audio_decode_thread_proxy_->RunsTasksOnCurrentThread();
 105     case CastEnvironment::VIDEO_ENCODER:
 106       return video_encode_thread_proxy_->RunsTasksOnCurrentThread();
 107     case CastEnvironment::VIDEO_DECODER:
 108       return video_decode_thread_proxy_->RunsTasksOnCurrentThread();
 109     case CastEnvironment::TRANSPORT:
 110       return transport_thread_proxy_->RunsTasksOnCurrentThread();
 111     default:
 112       NOTREACHED() << "Invalid thread identifier";
 113       return false;
 114   }
 115 }
 116
 117 base::TickClock* CastEnvironment::Clock() const { return clock_.get(); }
 118
 119 LoggingImpl* CastEnvironment::Logging() {
 120   DCHECK(CurrentlyOn(CastEnvironment::MAIN))
 121       << "Must be called from main thread";
 122   return logging_.get();
 123 }
 124
 125 }  // namespace cast
 126 }  // namespace media