Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 230 matching lines @@
   VEAClient(const TestStream& test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
             bool force_bitrate);
   virtual ~VEAClient();
   void CreateEncoder();
   void DestroyEncoder();
 
   // VideoDecodeAccelerator::Client implementation.
-  void NotifyInitializeDone() OVERRIDE;
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) OVERRIDE;
   void BitstreamBufferReady(int32 bitstream_buffer_id,
                             size_t payload_size,
                             bool key_frame) OVERRIDE;
   void NotifyError(VideoEncodeAccelerator::Error error) OVERRIDE;
 
  private:
   bool has_encoder() { return encoder_.get(); }
@@ skipping 123 matching lines @@
   thread_checker_.DetachFromThread();
 }
 
 VEAClient::~VEAClient() { CHECK(!has_encoder()); }
 
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(!has_encoder());
 
   encoder_.reset(new ExynosVideoEncodeAccelerator());
+  if (!encoder_) {
+    DLOG(ERROR) << "CreateEncoder() failed";
+    SetState(CS_ERROR);
+    return;
+  }
+  SetState(CS_ENCODER_SET);
 
-  SetState(CS_ENCODER_SET);
   DVLOG(1) << "Profile: " << test_stream_.requested_profile
            << ", requested bitrate: " << test_stream_.requested_bitrate;
-  encoder_->Initialize(kInputFormat,
-                       test_stream_.size,
-                       test_stream_.requested_profile,
-                       test_stream_.requested_bitrate,
-                       this);
+  if (!encoder_->Initialize(kInputFormat,
+                            test_stream_.size,
+                            test_stream_.requested_profile,
+                            test_stream_.requested_bitrate,
+                            this)) {
+    DLOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
+    SetState(CS_ERROR);
+    return;
+  }
+  SetInitialConfiguration();
+  SetState(CS_INITIALIZED);
 }
 
 void VEAClient::DestroyEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!has_encoder())
     return;
   encoder_.release()->Destroy();
 }
 
-void VEAClient::NotifyInitializeDone() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  SetInitialConfiguration();
-  SetState(CS_INITIALIZED);
-}
-
 void VEAClient::RequireBitstreamBuffers(unsigned int input_count,
                                         const gfx::Size& input_coded_size,
                                         size_t output_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ASSERT_EQ(state_, CS_INITIALIZED);
   SetState(CS_ENCODING);
 
   // TODO(posciak): For now we only support input streams that meet encoder
   // size requirements exactly (i.e. coded size == visible size).
   input_coded_size_ = input_coded_size;
@@ skipping 332 matching lines @@
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 
   return RUN_ALL_TESTS();
 }