[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/test/cast_benchmarks.cc

 // Copyright 2014 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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
@@ skipping 14 matching lines @@
 #include <stdint.h>
 
 #include <map>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/profiler.h"
+#include "base/memory/weak_ptr.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
@@ skipping 29 matching lines @@
 // The tests are commonly implemented with |kFrameTimerMs| RunTask function;
 // a normal video is 30 fps hence the 33 ms between frames.
 static const int kFrameTimerMs = 33;
 
 void UpdateCastTransportStatus(CastTransportStatus status) {
   bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
                  status == TRANSPORT_VIDEO_INITIALIZED);
   EXPECT_TRUE(result);
 }
 
-void AudioInitializationStatus(CastInitializationStatus status) {
-  EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
-}
-
-void VideoInitializationStatus(CastInitializationStatus status) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
+void ExpectSuccessAndRunCallback(const base::Closure& done_cb,
+                                 OperationalStatus status) {
+  EXPECT_EQ(STATUS_INITIALIZED, status);
+  done_cb.Run();
 }
 
 void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events,
                      const std::vector<FrameEvent>& frame_events) {
 }
 
 }  // namespace
 
 // Wraps a CastTransportSender and records some statistics about
 // the data that goes through it.
@@ skipping 239 matching lines @@
             &receiver_to_sender_));
 
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
                                           transport_receiver_.get());
 
     cast_sender_ =
         CastSender::Create(cast_environment_sender_, &transport_sender_);
 
-    // Initializing audio and video senders.
-    cast_sender_->InitializeAudio(audio_sender_config_,
-                                  base::Bind(&AudioInitializationStatus));
-    cast_sender_->InitializeVideo(video_sender_config_,
-                                  base::Bind(&VideoInitializationStatus),
-                                  CreateDefaultVideoEncodeAcceleratorCallback(),
-                                  CreateDefaultVideoEncodeMemoryCallback());
+    // Initializing audio and video senders.  The funny dance here is to
+    // synchronize on the asynchronous initialization process.
+    base::RunLoop run_loop;
+    base::WeakPtrFactory<RunOneBenchmark> weak_factory(this);
+    cast_sender_->InitializeAudio(
+        audio_sender_config_,
+        base::Bind(&ExpectSuccessAndRunCallback, run_loop.QuitClosure()));
+    run_loop.Run();  // Wait for quit closure to run.
+    weak_factory.InvalidateWeakPtrs();
+    cast_sender_->InitializeVideo(
+        video_sender_config_,
+        base::Bind(&ExpectSuccessAndRunCallback, run_loop.QuitClosure()),
+        CreateDefaultVideoEncodeAcceleratorCallback(),
+        CreateDefaultVideoEncodeMemoryCallback());
+    run_loop.Run();  // Wait for quit closure to run.
+    weak_factory.InvalidateWeakPtrs();
 
     receiver_to_sender_.Initialize(
         CreateSimplePipe(p).Pass(),
         transport_sender_.PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
     sender_to_receiver_.Initialize(
         CreateSimplePipe(p).Pass(),
         transport_receiver_->PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
   }
@@ skipping 381 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }