media: Don't create a new MediaCodec during AVDA teardown

media/gpu/avda_codec_allocator.h

 // Copyright 2016 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.
 
 #ifndef MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 #define MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 122 matching lines @@
   // longer attached to a MediaCodec, or the MediaCodec it was attached to is
   // was released with ReleaseMediaCodec().
   void DeallocateSurface(AVDACodecAllocatorClient* client, int surface_id);
 
   // Create and configure a MediaCodec synchronously.
   std::unique_ptr<VideoCodecBridge> CreateMediaCodecSync(
       scoped_refptr<CodecConfig> codec_config);
 
   // Create and configure a MediaCodec asynchronously. The result is delivered
   // via OnCodecConfigured().
-  void CreateMediaCodecAsync(base::WeakPtr<AVDACodecAllocatorClient> client,
-                             scoped_refptr<CodecConfig> codec_config);
+  virtual void CreateMediaCodecAsync(
+      base::WeakPtr<AVDACodecAllocatorClient> client,
+      scoped_refptr<CodecConfig> codec_config);
 
   // Asynchronously release |media_codec| with the attached surface.
   // TODO(watk): Bundle the MediaCodec and surface together so you can't get
   // this pairing wrong.
   void ReleaseMediaCodec(std::unique_ptr<VideoCodecBridge> media_codec,
                          TaskType task_type,
                          int surface_id);
 
   // Returns a hint about whether the construction thread has hung for
   // |task_type|.  Note that if a thread isn't started, then we'll just return
   // "not hung", since it'll run on the current thread anyway.  The hang
   // detector will see no pending jobs in that case, so it's automatic.
   bool IsThreadLikelyHung(TaskType task_type);
 
   // Return true if and only if there is any AVDA registered.
   bool IsAnyRegisteredAVDA();
 
   // Return the task type to use for a new codec allocation, or nullopt if
   // both threads are hung.
   base::Optional<TaskType> TaskTypeForAllocation();
 
   // Return the task runner for tasks of type |type|.
   scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerFor(TaskType task_type);
 
   // Return a reference to the thread for unit tests.
   base::Thread& GetThreadForTesting(TaskType task_type);
 
+ protected:
+  // |tick_clock| and |stop_event| are for tests only.
+  AVDACodecAllocator(base::TickClock* tick_clock = nullptr,
+                     base::WaitableEvent* stop_event = nullptr);
+  virtual ~AVDACodecAllocator();
+
  private:
   friend class AVDACodecAllocatorTest;
 
   struct OwnerRecord {
     AVDACodecAllocatorClient* owner = nullptr;
     AVDACodecAllocatorClient* waiter = nullptr;
   };
 
   class HangDetector : public base::MessageLoop::TaskObserver {
    public:
@@ skipping 14 matching lines @@
   };
 
   // Handy combination of a thread and hang detector for it.
   struct ThreadAndHangDetector {
     ThreadAndHangDetector(const std::string& name, base::TickClock* tick_clock)
         : thread(name), hang_detector(tick_clock) {}
     base::Thread thread;
     HangDetector hang_detector;
   };
 
-  // |tick_clock| and |stop_event| are for tests only.
-  AVDACodecAllocator(base::TickClock* tick_clock = nullptr,
-                     base::WaitableEvent* stop_event = nullptr);
-  ~AVDACodecAllocator();
-
   void OnMediaCodecAndSurfaceReleased(int surface_id);
 
   // Stop the thread indicated by |index|. This signals stop_event_for_testing_
   // after both threads are stopped.
   void StopThreadTask(size_t index);
 
   // All registered AVDAs.
   std::set<AVDACodecAllocatorClient*> clients_;
 
   // Indexed by surface id.
@@ skipping 13 matching lines @@
 
   // For canceling pending StopThreadTask()s.
   base::WeakPtrFactory<AVDACodecAllocator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDACodecAllocator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_