[Mojo Video Capture] Replace RESOURCE_UTILIZATION with interface ReceiverLoadObserver

media/capture/video/video_capture_device_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.
 
 #include "media/capture/video/video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 96 matching lines @@
       base::Callback<void(const VideoCaptureFormat&)> frame_cb)
       : main_thread_(base::ThreadTaskRunnerHandle::Get()), frame_cb_(frame_cb) {
     ON_CALL(*this, OnError(_, _)).WillByDefault(Invoke(DumpError));
   }
 
   void OnIncomingCapturedData(const uint8_t* data,
                               int length,
                               const VideoCaptureFormat& format,
                               int rotation,
                               base::TimeTicks reference_time,
-                              base::TimeDelta timestamp) override {
+                              base::TimeDelta timestamp,
+                              int frame_id) override {
     ASSERT_GT(length, 0);
     ASSERT_TRUE(data);
     main_thread_->PostTask(FROM_HERE, base::Bind(frame_cb_, format));
   }
 
   // Trampoline methods to workaround GMOCK problems with std::unique_ptr<>.
   std::unique_ptr<Buffer> ReserveOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) override {
     DoReserveOutputBuffer();
     NOTREACHED() << "This should never be called";
     return std::unique_ptr<Buffer>();
   }
   void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
-                                const VideoCaptureFormat& frame_format,
+                                const VideoCaptureFormat& format,
                                 base::TimeTicks reference_time,
-                                base::TimeDelta timestamp) override {
+                                base::TimeDelta timestamp,
+                                int frame_id) override {
     DoOnIncomingCapturedBuffer();
   }
   void OnIncomingCapturedVideoFrame(std::unique_ptr<Buffer> buffer,
-                                    scoped_refptr<VideoFrame> frame) override {
+                                    scoped_refptr<VideoFrame> frame,
+                                    int buffer_id) override {
     DoOnIncomingCapturedVideoFrame();
   }
   std::unique_ptr<Buffer> ResurrectLastOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) {
     DoResurrectLastOutputBuffer();
     NOTREACHED() << "This should never be called";
     return std::unique_ptr<Buffer>();
   }
@@ skipping 479 matching lines @@
 
   device->GetPhotoCapabilities(std::move(scoped_get_callback));
   run_loop.Run();
 
   ASSERT_TRUE(image_capture_client_->capabilities());
 
   device->StopAndDeAllocate();
 }
 
 };  // namespace media