RESOURCE_UTILIZATION in VideoFrameMetadata, a consumer feedback signal.

content/browser/renderer_host/media/video_capture_controller_unittest.cc

 // Copyright (c) 2012 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.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_capture_types.h"
+#include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if !defined(OS_ANDROID)
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
 #endif
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::SaveArg;
 
 namespace content {
 
 class MockVideoCaptureControllerEventHandler
     : public VideoCaptureControllerEventHandler {
  public:
   explicit MockVideoCaptureControllerEventHandler(
       VideoCaptureController* controller)
-      : controller_(controller) {}
+      : controller_(controller),
+        resource_utilization_(-1.0) {}
   ~MockVideoCaptureControllerEventHandler() override {}
 
   // These mock methods are delegated to by our fake implementation of
   // VideoCaptureControllerEventHandler, to be used in EXPECT_CALL().
   MOCK_METHOD1(DoBufferCreated, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoBufferDestroyed, void(VideoCaptureControllerID));
   MOCK_METHOD2(DoBufferReady, void(VideoCaptureControllerID, const gfx::Size&));
   MOCK_METHOD1(DoMailboxBufferReady, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoEnded, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoError, void(VideoCaptureControllerID));
@@ skipping 17 matching lines @@
       const base::TimeTicks& timestamp,
       scoped_ptr<base::DictionaryValue> metadata) override {
     DoBufferReady(id, coded_size);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureController::ReturnBuffer,
                    base::Unretained(controller_),
                    id,
                    this,
                    buffer_id,
-                   0));
+                   0,
+                   resource_utilization_));
   }
   void OnMailboxBufferReady(
       VideoCaptureControllerID id,
       int buffer_id,
       const gpu::MailboxHolder& mailbox_holder,
       const gfx::Size& packed_frame_size,
       const base::TimeTicks& timestamp,
       scoped_ptr<base::DictionaryValue> metadata) override {
     DoMailboxBufferReady(id);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureController::ReturnBuffer,
                    base::Unretained(controller_),
                    id,
                    this,
                    buffer_id,
-                   mailbox_holder.sync_point));
+                   mailbox_holder.sync_point,
+                   resource_utilization_));
   }
   void OnEnded(VideoCaptureControllerID id) override {
     DoEnded(id);
     // OnEnded() must respond by (eventually) unregistering the client.
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(base::IgnoreResult(&VideoCaptureController::RemoveClient),
                    base::Unretained(controller_), id, this));
   }
 
   VideoCaptureController* controller_;
+  double resource_utilization_;
 };
 
 // Test class.
 class VideoCaptureControllerTest : public testing::Test {
  public:
   VideoCaptureControllerTest() {}
   ~VideoCaptureControllerTest() override {}
 
  protected:
   static const int kPoolSize = 3;
@@ skipping 214 matching lines @@
     EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1)).Times(1);
     EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1,_)).Times(1);
   }
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2)).Times(1);
     EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2,_)).Times(1);
   }
   scoped_refptr<media::VideoFrame> video_frame =
       WrapI420Buffer(capture_resolution, static_cast<uint8*>(buffer->data()));
+  ASSERT_FALSE(video_frame->metadata()->HasKey(
+      media::VideoFrameMetadata::RESOURCE_UTILIZATION));
+  client_a_->resource_utilization_ = 0.5;
+  client_b_->resource_utilization_ = -1.0;
   device_->OnIncomingCapturedVideoFrame(buffer.Pass(), video_frame,
                                         base::TimeTicks());
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
+  // Expect VideoCaptureController set the metadata in |video_frame| to hold a
+  // resource utilization of 0.5 (the largest of all reported values).
+  double resource_utilization_in_metadata = -1.0;
+  ASSERT_TRUE(video_frame->metadata()->GetDouble(
+      media::VideoFrameMetadata::RESOURCE_UTILIZATION,
+      &resource_utilization_in_metadata));
+  ASSERT_EQ(0.5, resource_utilization_in_metadata);
 
   // Second buffer which ought to use the same shared memory buffer. In this
   // case pretend that the Buffer pointer is held by the device for a long
   // delay. This shouldn't affect anything.
   scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer2 =
       device_->ReserveOutputBuffer(media::PIXEL_FORMAT_I420,
                                    capture_resolution);
   ASSERT_TRUE(buffer2.get());
   memset(buffer2->data(), buffer_no++, buffer2->size());
   video_frame =
       WrapI420Buffer(capture_resolution, static_cast<uint8*>(buffer2->data()));
+  ASSERT_FALSE(video_frame->metadata()->HasKey(
+      media::VideoFrameMetadata::RESOURCE_UTILIZATION));
+  client_a_->resource_utilization_ = 0.5;
+  client_b_->resource_utilization_ = 3.14;
   device_->OnIncomingCapturedVideoFrame(buffer2.Pass(), video_frame,
                                         base::TimeTicks());
 
   // The buffer should be delivered to the clients in any order.
   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1,_)).Times(1);
   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1,_)).Times(1);
   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2,_)).Times(1);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
+  // Expect VideoCaptureController set the metadata in |video_frame| to hold a
+  // resource utilization of 3.14 (the largest of all reported values).
+  resource_utilization_in_metadata = -1.0;
+  ASSERT_TRUE(video_frame->metadata()->GetDouble(
+      media::VideoFrameMetadata::RESOURCE_UTILIZATION,
+      &resource_utilization_in_metadata));
+  ASSERT_EQ(3.14, resource_utilization_in_metadata);
 
   // Add a fourth client now that some buffers have come through.
   controller_->AddClient(client_b_route_2,
                          client_b_.get(),
                          base::kNullProcessHandle,
                          1,
                          session_1);
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Third, fourth, and fifth buffers. Pretend they all arrive at the same time.
@@ skipping 316 matching lines @@
     EXPECT_EQ(coded_size.width(), size_and_rotation.output_resolution.width());
     EXPECT_EQ(coded_size.height(),
               size_and_rotation.output_resolution.height());
 
     EXPECT_EQ(kSessionId, controller_->RemoveClient(route_id, client_a_.get()));
     Mock::VerifyAndClearExpectations(client_a_.get());
   }
 }
 
 }  // namespace content