Revert of [Cast] Compute utilization metrics and add performance overlay.

media/cast/sender/video_encoder_unittest.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 <vector>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 201 matching lines @@
       video_frame_factory_ = video_encoder_->CreateVideoFrameFactory().Pass();
   }
 
   // Checks that |encoded_frame| matches expected values.  This is the method
   // bound in the callback returned from EncodeAndCheckDelivery().
   void DeliverEncodedVideoFrame(
       uint32 expected_frame_id,
       uint32 expected_last_referenced_frame_id,
       uint32 expected_rtp_timestamp,
       const base::TimeTicks& expected_reference_time,
-      scoped_ptr<SenderEncodedFrame> encoded_frame) {
+      scoped_ptr<EncodedFrame> encoded_frame) {
     EXPECT_TRUE(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     EXPECT_EQ(expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp);
     EXPECT_EQ(expected_reference_time, encoded_frame->reference_time);
 
     // The platform encoders are "black boxes" and may choose to vend key frames
     // and/or empty data at any time.  The software encoders, however, should
     // strictly adhere to expected behavior.
     if (is_testing_platform_encoder()) {
@@ skipping 13 matching lines @@
           << encoded_frame->frame_id;
     } else {
       if (expected_frame_id != expected_last_referenced_frame_id) {
         EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency);
       } else if (video_config_.max_number_of_video_buffers_used == 1) {
         EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency);
       }
       EXPECT_EQ(expected_last_referenced_frame_id,
                 encoded_frame->referenced_frame_id);
       EXPECT_FALSE(encoded_frame->data.empty());
-      ASSERT_TRUE(std::isfinite(encoded_frame->deadline_utilization));
-      EXPECT_LE(0.0, encoded_frame->deadline_utilization);
-      ASSERT_TRUE(std::isfinite(encoded_frame->lossy_utilization));
-      EXPECT_LE(0.0, encoded_frame->lossy_utilization);
     }
 
     ++count_frames_delivered_;
   }
 
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
   VideoSenderConfig video_config_;
   scoped_ptr<FakeVideoEncodeAcceleratorFactory> vea_factory_;
@@ skipping 182 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media