Cast: Flow hw encoder initialization error to extensions API

media/cast/sender/external_video_encoder_unittest.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.
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/sender/external_video_encoder.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/fake_video_encode_accelerator.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 using testing::_;
 
 namespace {
 
+void IgnoreInitializationStatus(CastInitializationStatus status) {}
+
 class VEAFactory {
  public:
   VEAFactory(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
              scoped_ptr<VideoEncodeAccelerator> vea)
       : task_runner_(task_runner), vea_(vea.Pass()) {}
 
   void CreateVideoEncodeAccelerator(
       const ReceiveVideoEncodeAcceleratorCallback& callback) {
     create_cb_ = callback;
   }
@@ skipping 91 matching lines @@
                             task_runner_,
                             task_runner_);
 
     fake_vea_ = new test::FakeVideoEncodeAccelerator(task_runner_,
                                                      &stored_bitrates_);
     scoped_ptr<VideoEncodeAccelerator> fake_vea(fake_vea_);
     VEAFactory vea_factory(task_runner_, fake_vea.Pass());
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment_,
         video_config_,
+        base::Bind(&IgnoreInitializationStatus),
         base::Bind(&VEAFactory::CreateVideoEncodeAccelerator,
                    base::Unretained(&vea_factory)),
         base::Bind(&CreateSharedMemory)));
     vea_factory.FinishCreatingVideoEncodeAccelerator();
   }
 
   virtual ~ExternalVideoEncoderTest() {}
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   test::FakeVideoEncodeAccelerator* fake_vea_;  // Owned by video_encoder_.
@@ skipping 75 matching lines @@
                           task_runner));
 
   std::vector<uint32> stored_bitrates;
   scoped_ptr<VideoEncodeAccelerator> fake_vea(
       new test::FakeVideoEncodeAccelerator(task_runner, &stored_bitrates));
   VEAFactory vea_factory(task_runner, fake_vea.Pass());
 
   scoped_ptr<ExternalVideoEncoder> video_encoder(new ExternalVideoEncoder(
       cast_environment,
       video_config,
+      base::Bind(&IgnoreInitializationStatus),
       base::Bind(&VEAFactory::CreateVideoEncodeAccelerator,
                  base::Unretained(&vea_factory)),
       base::Bind(&CreateSharedMemory)));
 
   video_encoder.reset();
   vea_factory.FinishCreatingVideoEncodeAccelerator();
   task_runner->RunTasks();
 }
 
 }  // namespace cast
 }  // namespace media