[Mojo Video Capture] Replace RESOURCE_UTILIZATION with interface ReceiverLoadObserver

media/capture/content/thread_safe_capture_oracle.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/capture/content/thread_safe_capture_oracle.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 63 matching lines @@
     if (!oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time)) {
       // This is a normal and acceptable way to drop a frame. We've hit our
       // capture rate limit: for example, the content is animating at 60fps but
       // we're capturing at 30fps.
       TRACE_EVENT_INSTANT1("gpu.capture", "FpsRateLimited",
                            TRACE_EVENT_SCOPE_THREAD, "trigger",
                            VideoCaptureOracle::EventAsString(event));
       return false;
     }
 
+    frame_number = oracle_.next_frame_number();
     visible_size = oracle_.capture_size();
     // TODO(miu): Clients should request exact padding, instead of this
     // memory-wasting hack to make frames that are compatible with all HW
     // encoders.  http://crbug.com/555911
     coded_size.SetSize(base::bits::Align(visible_size.width(), 16),
                        base::bits::Align(visible_size.height(), 16));
 
     if (event == VideoCaptureOracle::kPassiveRefreshRequest) {
       output_buffer = client_->ResurrectLastOutputBuffer(
           coded_size, params_.requested_format.pixel_format,
-          params_.requested_format.pixel_storage);
+          params_.requested_format.pixel_storage, frame_number);
       if (!output_buffer) {
         TRACE_EVENT_INSTANT0("gpu.capture", "ResurrectionFailed",
                              TRACE_EVENT_SCOPE_THREAD);
         return false;
       }
     } else {
       output_buffer = client_->ReserveOutputBuffer(
           coded_size, params_.requested_format.pixel_format,
-          params_.requested_format.pixel_storage);
+          params_.requested_format.pixel_storage, frame_number);
     }
 
     // Get the current buffer pool utilization and attenuate it: The utilization
     // reported to the oracle is in terms of a maximum sustainable amount (not
     // the absolute maximum).
     attenuated_utilization = client_->GetBufferPoolUtilization() *
                              (100.0 / kTargetMaxPoolUtilizationPercent);
 
     if (!output_buffer) {
       TRACE_EVENT_INSTANT2(
           "gpu.capture", "PipelineLimited", TRACE_EVENT_SCOPE_THREAD, "trigger",
           VideoCaptureOracle::EventAsString(event), "atten_util_percent",
           base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
       oracle_.RecordWillNotCapture(attenuated_utilization);
       return false;
     }
 
-    frame_number = oracle_.RecordCapture(attenuated_utilization);
+    oracle_.RecordCapture(attenuated_utilization);
     estimated_frame_duration = oracle_.estimated_frame_duration();
   }  // End of critical section.
 
   if (attenuated_utilization >= 1.0) {
     TRACE_EVENT_INSTANT2(
         "gpu.capture", "NearlyPipelineLimited", TRACE_EVENT_SCOPE_THREAD,
         "trigger", VideoCaptureOracle::EventAsString(event),
         "atten_util_percent",
         base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
   }
@@ skipping 89 matching lines @@
                                  params_.requested_format.frame_rate);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_BEGIN_TIME,
                                     capture_begin_time);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_END_TIME,
                                     base::TimeTicks::Now());
     frame->metadata()->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
                                     estimated_frame_duration);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
                                     reference_time);
 
-    frame->AddDestructionObserver(
-        base::Bind(&ThreadSafeCaptureOracle::DidConsumeFrame, this,
-                   frame_number, frame->metadata()));
-
     client_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
   }
 }
 
-void ThreadSafeCaptureOracle::DidConsumeFrame(
+void ThreadSafeCaptureOracle::OnConsumerReportingUtilization(
     int frame_number,
-    const media::VideoFrameMetadata* metadata) {
-  // Note: This function may be called on any thread by the VideoFrame
-  // destructor.  |metadata| is still valid for read-access at this point.
-  double utilization = -1.0;
-  if (metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
-                          &utilization)) {
-    base::AutoLock guard(lock_);
-    oracle_.RecordConsumerFeedback(frame_number, utilization);
-  }
+    double utilization) {
+  base::AutoLock guard(lock_);
+  oracle_.RecordConsumerFeedback(frame_number, utilization);
 }
 
 }  // namespace media