Adds fake hardware video encoder.

media/video/fake_video_encode_accelerator.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/test/fake_video_encode_accelerator.h"
+#include "media/video/fake_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
 
 namespace media {
-namespace cast {
-namespace test {
 
 static const unsigned int kMinimumInputCount = 1;
 static const size_t kMinimumOutputBufferSize = 123456;
 
+struct FakeVideoEncodeAccelerator::BitstreamBufferRef {

[wuchengli, 2014/12/12 03:35:50]

Can remove because not used anymore.

[hellner1, 2014/12/12 19:24:41]

Done.

+  BitstreamBufferRef(int id, scoped_ptr<base::SharedMemory> shm, size_t size)
+      : id(id), shm(shm.Pass()), size(size) {}
+  const int id;
+  const scoped_ptr<base::SharedMemory> shm;
+  const size_t size;
+};
+
 FakeVideoEncodeAccelerator::FakeVideoEncodeAccelerator(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    std::vector<uint32>* stored_bitrates)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
-      stored_bitrates_(stored_bitrates),
+      will_initialization_succeed_(true),
       client_(NULL),
       first_(true),
-      will_initialization_succeed_(true),
-      weak_this_factory_(this) {
-  DCHECK(stored_bitrates_);
-}
+      weak_this_factory_(this) {}
 
 FakeVideoEncodeAccelerator::~FakeVideoEncodeAccelerator() {
   weak_this_factory_.InvalidateWeakPtrs();
 }
 
 std::vector<VideoEncodeAccelerator::SupportedProfile>
 FakeVideoEncodeAccelerator::GetSupportedProfiles() {
   return std::vector<VideoEncodeAccelerator::SupportedProfile>();
 }
 
 bool FakeVideoEncodeAccelerator::Initialize(
-    media::VideoFrame::Format input_format,
+    VideoFrame::Format input_format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32 initial_bitrate,
     Client* client) {
-  if (!will_initialization_succeed_)
-    return false;
-  client_ = client;
-  if (output_profile != media::VP8PROFILE_ANY &&
-      output_profile != media::H264PROFILE_MAIN) {
+  if (!will_initialization_succeed_) {
     return false;
   }
+  if (output_profile == VIDEO_CODEC_PROFILE_UNKNOWN ||
+      output_profile > VIDEO_CODEC_PROFILE_MAX) {
+    return false;
+  }
+  client_ = client;
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeVideoEncodeAccelerator::DoRequireBitstreamBuffers,
                  weak_this_factory_.GetWeakPtr(),
                  kMinimumInputCount,
                  input_visible_size,
                  kMinimumOutputBufferSize));
   return true;
 }
 
-void FakeVideoEncodeAccelerator::Encode(const scoped_refptr<VideoFrame>& frame,
-                                        bool force_keyframe) {
+void FakeVideoEncodeAccelerator::Encode(
+    const scoped_refptr<VideoFrame>& frame,
+    bool force_keyframe) {
   DCHECK(client_);
-  DCHECK(!available_buffer_ids_.empty());
+  DCHECK(!available_buffers_.empty());
 
-  // Fake that we have encoded the frame; resulting in using the full output
-  // buffer.
-  int32 id = available_buffer_ids_.front();
-  available_buffer_ids_.pop_front();
+  BitstreamBuffer buffer = available_buffers_.front();
+  int32 id = buffer.id();
+  bool is_key_frame = first_ || force_keyframe;
+  first_ = false;
 
-  bool is_key_fame = force_keyframe;
-  if (first_) {
-    is_key_fame = true;
-    first_ = false;
-  }
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&FakeVideoEncodeAccelerator::DoBitstreamBufferReady,
-                 weak_this_factory_.GetWeakPtr(),
-                 id,
-                 kMinimumOutputBufferSize,
-                 is_key_fame));
+  client_->BitstreamBufferReady(id, kMinimumOutputBufferSize, is_key_frame);

[wuchengli, 2014/12/12 03:35:50]

Sorry. After thinking again, all client methods (RequireBitstreamBuffers and
BitstreamBufferReady) should be called from the same thread to avoid
synchronization issues. This should be changed back to PostTask.

But I don't know why SendDummyFrameForTesting calls it directly.

[hellner1, 2014/12/12 19:24:41]

This class assumes that it is called on the task_runner_ thread which means that
all callbacks will automatically be on that thread as there are no other threads
in this class.

However, cast seems to use the class slightly differently so, to play it safe,
all callbacks now post to the task_runner_ thread.

Note that I had to start queuing up encodes in queued_frames_ as the unittest
will call encode more times than there are output buffers. Posting
BitstreamBufferReady means that they will be queued up and not worked on until
after the unittest's encode loop finishes.

[wuchengli, 2014/12/13 02:10:22]

Basically all VEA methods should be called on the same thread. All callbacks
(that is, VEA::Client methods) should be called on the same thread. Those two
threads do not have to be the same. So the latest patchset is not correct.
Several FakeVEA methods and FakeVEA::DoBitstreamBufferReady can access
|available_buffers_| from two different threads.

So DoBitstreamBufferReady should have only one line to post a task like before.
Rename BitstreamBufferReday to EncodeTask. This means all the class member
variables will be accessed by the same thread.

void FakeVideoEncodeAccelerator::EncodeTask() {
  while (!queued_frames_.empty() && !available_buffers_.empty()) {
    bool force_key_frame = queued_frames_.front();
    queued_frames_.pop();
    int32 bitstream_buffer_id = available_buffers_.front().id();
    available_buffers_.pop_front();
    bool key_frame = first_ ||  force_key_frame;
    first_ = false;
    task_runner_->PostTask(	
        FROM_HERE,
base::Bind(&FakeVideoEncodeAccelerator::DoBitstreamBufferReady...);
  }
}

void FakeVideoEncodeAccelerator::DoBitstreamBufferReady() {
  DCHECK(task_runner_->BelongsToCurrentThread());
  client_->BitstreamBufferReady(
      bitstream_buffer_id,
      kMinimumOutputBufferSize,
      key_frame);
}

What do you mean cast uses the class differently? Originally all callbacks were
posted to the |task_runner_| already. But I think SendDummyFrameForTesting
should also use PostTask(&client_->BitstreamBufferReady) (because all callbacks
should run on |task_runner_|). In the cast unittests, all
SendDummyFrameForTesting should be followed by task_runner_->RunTasks(); to make
sure it finishes. 
You are right. This class needs to add |queued_frames_|.

+  available_buffers_.pop_front();
 }
 
 void FakeVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
-  available_buffer_ids_.push_back(buffer.id());
+  available_buffers_.push_back(buffer);
 }
 
 void FakeVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
-  stored_bitrates_->push_back(bitrate);
+  stored_bitrates_.push_back(bitrate);
 }
 
 void FakeVideoEncodeAccelerator::Destroy() { delete this; }
 
 void FakeVideoEncodeAccelerator::SendDummyFrameForTesting(bool key_frame) {
-  DoBitstreamBufferReady(0, 23, key_frame);
+  client_->BitstreamBufferReady(0, 23, key_frame);
+}
+
+void FakeVideoEncodeAccelerator::SetWillInitializationSucceed(
+    bool will_initialization_succeed) {
+  will_initialization_succeed_ = will_initialization_succeed;
 }
 
 void FakeVideoEncodeAccelerator::DoRequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) const {
   client_->RequireBitstreamBuffers(
       input_count, input_coded_size, output_buffer_size);
 }
 
-void FakeVideoEncodeAccelerator::DoBitstreamBufferReady(
-    int32 bitstream_buffer_id,
-    size_t payload_size,
-    bool key_frame) const {
-  client_->BitstreamBufferReady(bitstream_buffer_id, payload_size, key_frame);
-}
-
-}  // namespace test
-}  // namespace cast
 }  // namespace media