Cast: Flow hw encoder initialization error to extensions API

media/cast/sender/external_video_encoder.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 "media/cast/sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 96 matching lines @@
     bool result = video_encode_accelerator_->Initialize(
         media::VideoFrame::I420,
         gfx::Size(video_config.width, video_config.height),
         output_profile,
         video_config.start_bitrate,
         this);
 
     UMA_HISTOGRAM_BOOLEAN("Cast.Sender.VideoEncodeAcceleratorInitializeSuccess",
                           result);
     if (!result) {
-      NotifyError(VideoEncodeAccelerator::kInvalidArgumentError);
+      cast_environment_->PostTask(
+          CastEnvironment::MAIN,
+          FROM_HERE,
+          base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_,
+                     false));
       return;
     }
 
     // Wait until shared memory is allocated to indicate that encoder is
     // initialized.
   }
 
   // Destroy the VEA on the correct thread.
   void Destroy() {
     DCHECK(encoder_task_runner_.get());
@@ skipping 207 matching lines @@
     for (size_t i = 0; i < output_buffers_.size(); ++i) {
       video_encode_accelerator_->UseOutputBitstreamBuffer(
           media::BitstreamBuffer(static_cast<int32>(i),
                                  output_buffers_[i]->handle(),
                                  output_buffers_[i]->mapped_size()));
     }
 
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_));
+        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_,
+                   true));
   }
 
   static void DestroyVideoEncodeAcceleratorOnEncoderThread(
       scoped_ptr<media::VideoEncodeAccelerator> vea) {
     // VEA::~VEA specialization takes care of calling Destroy() on the VEA impl.
   }
 
   friend class base::RefCountedThreadSafe<LocalVideoEncodeAcceleratorClient>;
 
   virtual ~LocalVideoEncodeAcceleratorClient() {
@@ skipping 16 matching lines @@
 
   // FIFO list.
   std::list<EncodedFrameReturnData> encoded_frame_data_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalVideoEncodeAcceleratorClient);
 };
 
 ExternalVideoEncoder::ExternalVideoEncoder(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
+    const CastInitializationCallback& initialization_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb)
     : video_config_(video_config),
       cast_environment_(cast_environment),
       encoder_active_(false),
       key_frame_requested_(false),
+      initialization_cb_(initialization_cb),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   video_accelerator_client_ =
       LocalVideoEncodeAcceleratorClient::Create(cast_environment_,
                                                 create_vea_cb,
                                                 create_video_encode_mem_cb,
                                                 weak_factory_.GetWeakPtr());
   DCHECK(video_accelerator_client_.get());
 }
 
 ExternalVideoEncoder::~ExternalVideoEncoder() {
 }
 
-void ExternalVideoEncoder::EncoderInitialized() {
+void ExternalVideoEncoder::EncoderInitialized(bool success) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  encoder_active_ = true;
+  encoder_active_ = success;
+  DCHECK(!initialization_cb_.is_null());
+  initialization_cb_.Run(
+      success ?
+      STATUS_VIDEO_INITIALIZED : STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED);
+  initialization_cb_.Reset();
 }
 
 void ExternalVideoEncoder::EncoderError() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   encoder_active_ = false;
 }
 
 void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
     scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 50 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   key_frame_requested_ = true;
 }
 
 // Inform the encoder to only reference frames older or equal to frame_id;
 void ExternalVideoEncoder::LatestFrameIdToReference(uint32 /*frame_id*/) {
   // Do nothing not supported.
 }
 }  //  namespace cast
 }  //  namespace media