media: Fix a flaky AVDACodecAllocator test

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 159 matching lines @@
   // there is no thread that can support it.
   TaskType TaskTypeForAllocation();
 
   // Return a reference to the thread for unit tests.
   base::Thread& GetThreadForTesting(TaskType task_type);
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDACodecAllocator>;
   friend class AVDACodecAllocatorTest;
 
-  // Things that our unit test needs.  We guarantee that we'll access none of
-  // it, from any thread, after we are destructed.
-  struct TestInformation {
-    TestInformation();
-    ~TestInformation();
-    // Optional clock source.
-    std::unique_ptr<base::TickClock> tick_clock_;
-
-    // Optional event that we'll signal when stopping the AUTO_CODEC thread.
-    std::unique_ptr<base::WaitableEvent> stop_event_;
-  };
-
   struct OwnerRecord {
     AVDACodecAllocatorClient* owner = nullptr;
     AVDACodecAllocatorClient* waiter = nullptr;
   };
 
   class HangDetector : public base::MessageLoop::TaskObserver {
    public:
     HangDetector(base::TickClock* tick_clock);
     void WillProcessTask(const base::PendingTask& pending_task) override;
     void DidProcessTask(const base::PendingTask& pending_task) override;
@@ skipping 11 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;
   };
 
-  // |test_info| is owned by the unit test.
-  AVDACodecAllocator(TestInformation* test_info = nullptr);
+  // |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|, then signal |event| if provided.
   void StopThreadTask(size_t index, base::WaitableEvent* event = nullptr);
 
   // All registered AVDAs.
   std::set<AVDACodecAllocatorClient*> clients_;
 
   // Indexed by surface id.
   std::map<int32_t, OwnerRecord> surface_owners_;
 
   // Waitable events for ongoing release tasks indexed by surface id so we can
   // wait on the codec release if the surface attached to it is being destroyed.
   std::map<int32_t, base::WaitableEvent> pending_codec_releases_;
 
   // Threads for each of TaskType.  They are started / stopped as avda instances
   // show and and request them.  The vector indicies must match TaskType.
   std::vector<ThreadAndHangDetector*> threads_;
 
   base::ThreadChecker thread_checker_;
 
-  // Optional, used for unit testing.  We do not own this.
-  TestInformation* test_info_;
+  base::WaitableEvent* stop_event_for_testing_;
 
   // 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_