media: Check StartThread() result in AVDATimerManager.

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/task_runner_util.h"
+#include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/media/android_copying_backing_strategy.h"
 #include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "content/common/gpu/media/shared_memory_region.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_util.h"
@@ skipping 143 matching lines @@
 // behind this is that, if we're waiting for long enough, then either (a)
 // MediaCodec is broken or (b) MediaCodec is waiting on us to change state
 // (e.g., get new demuxed data / get a free picture buffer / return an output
 // buffer to MediaCodec).  This is inherently a race, since we don't know if
 // MediaCodec is broken or just slow.  Since the MediaCodec API doesn't let
 // us wait on MediaCodec state changes prior to L, we more or less have to
 // time out or keep polling forever in some common cases.
 class AVDATimerManager {
  public:
   // Make sure that the construction thread is started for |avda_instance|.
-  void StartThread(AndroidVideoDecodeAccelerator* avda_instance) {
-    if (thread_avda_instances_.empty())
-      construction_thread_.Start();
+  bool StartThread(AndroidVideoDecodeAccelerator* avda_instance) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    if (thread_avda_instances_.empty()) {
+      if (!construction_thread_.Start()) {
+        LOG(ERROR) << "Failed to start construction thread.";
+        return false;
+      }
+    }
 
     thread_avda_instances_.insert(avda_instance);
+    return true;
   }
 
   // |avda_instance| will no longer need the construction thread.  Stop the
   // thread if this is the last instance.
   void StopThread(AndroidVideoDecodeAccelerator* avda_instance) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
     thread_avda_instances_.erase(avda_instance);
     if (thread_avda_instances_.empty())
       construction_thread_.Stop();
   }
 
   // Request periodic callback of |avda_instance|->DoIOTask(). Does nothing if
   // the instance is already registered and the timer started. The first request
   // will start the repeating timer on an interval of DecodePollDelay().
   void StartTimer(AndroidVideoDecodeAccelerator* avda_instance) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
     timer_avda_instances_.insert(avda_instance);
 
     // If the timer is running, StopTimer() might have been called earlier, if
     // so remove the instance from the pending erasures.
     if (timer_running_)
       pending_erase_.erase(avda_instance);
 
     if (io_timer_.IsRunning())
       return;
     io_timer_.Start(FROM_HERE, DecodePollDelay(), this,
                     &AVDATimerManager::RunTimer);
   }
 
   // Stop callbacks to |avda_instance|->DoIOTask(). Does nothing if the instance
   // is not registered. If there are no instances left, the repeating timer will
   // be stopped.
   void StopTimer(AndroidVideoDecodeAccelerator* avda_instance) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
     // If the timer is running, defer erasures to avoid iterator invalidation.
     if (timer_running_) {
       pending_erase_.insert(avda_instance);
       return;
     }
 
     timer_avda_instances_.erase(avda_instance);
     if (timer_avda_instances_.empty())
       io_timer_.Stop();
   }
 
   // Eventually, we should run the timer on this thread.  For now, we just keep
   // it as a convenience for construction.
   scoped_refptr<base::SingleThreadTaskRunner> ConstructionTaskRunner() {
+    DCHECK(thread_checker_.CalledOnValidThread());
     return construction_thread_.task_runner();
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDATimerManager>;
 
   AVDATimerManager() : construction_thread_("AVDAThread") {}
   ~AVDATimerManager() { NOTREACHED(); }
 
   void RunTimer() {
@@ skipping 24 matching lines @@
   // Since we can't delete while iterating when using a set, defer erasure until
   // after iteration complete.
   bool timer_running_ = false;
   std::set<AndroidVideoDecodeAccelerator*> pending_erase_;
 
   // Repeating timer responsible for draining pending IO to the codecs.
   base::RepeatingTimer io_timer_;
 
   base::Thread construction_thread_;
 
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::CodecConfig::CodecConfig() {}
 
 AndroidVideoDecodeAccelerator::CodecConfig::~CodecConfig() {}
 
@@ skipping 114 matching lines @@
   // TODO(watk,liberato): move this into the strategy.
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       strategy_->GetSurfaceTexture();
   if (surface_texture) {
     on_frame_available_handler_ =
         new OnFrameAvailableHandler(this, surface_texture);
   }
 
   // Start the thread for async configuration, even if we don't need it now.
   // ResetCodecState might rebuild the codec later, for example.
-  g_avda_timer.Pointer()->StartThread(this);
+  if (!g_avda_timer.Pointer()->StartThread(this)) {
+    LOG(ERROR) << "Failed to start thread for AVDA timer";
+    return false;
+  }
 
   // If we are encrypted, then we aren't able to create the codec yet.
   if (is_encrypted_)
     return true;
 
   if (deferred_initialization_pending_) {
     ConfigureMediaCodecAsynchronously();
     return true;
   }
 
@@ skipping 902 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace content