Updated latency fixture and refactored connection helper

remoting/test/test_video_renderer_unittest.cc

 // Copyright 2015 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 "remoting/test/test_video_renderer.h"
 
 #include <cmath>
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "media/base/video_frame.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/codec/video_encoder_vpx.h"
 #include "remoting/proto/video.pb.h"
+#include "remoting/test/rgb_value.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
 namespace {
 
 // Used to verify if image pattern is matched.
 void ProcessPacketDoneHandler(const base::Closure& done_closure,
                               bool* handler_called) {
   *handler_called = true;
@@ skipping 50 matching lines @@
   scoped_ptr<VideoEncoder> encoder_;
 
  private:
   // testing::Test interface.
   void SetUp() override;
 
   // Set image pattern, send video packet and returns if the expected pattern is
   // matched.
   bool SendPacketAndWaitForMatch(scoped_ptr<VideoPacket> packet,
                                  const webrtc::DesktopRect& expected_rect,
-                                 uint32_t expected_average_color);
+                                 const RGBValue& expected_average_color);
 
   // Returns the average color value of pixels fall within |rect|.
   // NOTE: Callers should not release the objects.
-  uint32_t CalculateAverageColorValueForFrame(
+  RGBValue CalculateAverageColorValueForFrame(
       const webrtc::DesktopFrame* frame,
       const webrtc::DesktopRect& rect) const;
 
   // Return the mean error of two frames over all pixels, where error at each
   // pixel is the root mean square of the errors in the R, G and B components,
   // each normalized to [0, 1].
   double CalculateError(const webrtc::DesktopFrame* original_frame,
                         const webrtc::DesktopFrame* decoded_frame) const;
 
   // Fill a desktop frame with a gradient.
@@ skipping 57 matching lines @@
 
   // The original frame is compared to the decoded video frame to check that
   // the mean error over all pixels does not exceed a given limit.
   double error = CalculateError(original_frame.get(), buffer_copy.get());
   EXPECT_LT(error, error_limit);
 }
 
 bool TestVideoRendererTest::SendPacketAndWaitForMatch(
     scoped_ptr<VideoPacket> packet,
     const webrtc::DesktopRect& expected_rect,
-    uint32_t expected_average_color) {
+    const RGBValue& expected_average_color) {
   DCHECK(!run_loop_ || !run_loop_->running());
   DCHECK(!timer_->IsRunning());
   run_loop_.reset(new base::RunLoop());
 
   // Set an extremely long time: 10 min to prevent bugs from hanging the system.
   // NOTE: We've seen cases which take up to 1 min to process a packet, so an
   // extremely long time as 10 min is chosen to avoid being variable/flaky.
   timer_->Start(FROM_HERE, base::TimeDelta::FromMinutes(10),
                 run_loop_->QuitClosure());
 
@@ skipping 35 matching lines @@
 void TestVideoRendererTest::TestImagePatternMatch(
     int screen_width,
     int screen_height,
     const webrtc::DesktopRect& expected_rect,
     bool expect_to_match) {
   DCHECK(encoder_);
   DCHECK(test_video_renderer_);
 
   scoped_ptr<webrtc::DesktopFrame> frame =
       CreateDesktopFrameWithGradient(screen_width, screen_height);
-  uint32_t expected_average_color =
+  RGBValue expected_average_color =
       CalculateAverageColorValueForFrame(frame.get(), expected_rect);
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame.get());
 
   if (expect_to_match) {
     EXPECT_TRUE(SendPacketAndWaitForMatch(packet.Pass(), expected_rect,
                                           expected_average_color));
   } else {
     // Shift each channel by 128.
     // e.g. (10, 127, 200) -> (138, 255, 73).
     // In this way, the error between expected color and true value is always
     // around 0.5.
-    int red_shift = (((expected_average_color >> 16) & 0xFF) + 128) % 255;
-    int green_shift = (((expected_average_color >> 8) & 0xFF) + 128) % 255;
-    int blue_shift = ((expected_average_color & 0xFF) + 128) % 255;
+    int red_shift = (expected_average_color.red + 128) % 255;
+    int green_shift = (expected_average_color.green + 128) % 255;
+    int blue_shift = (expected_average_color.blue + 128) % 255;
 
-    int expected_average_color_shift =
-        0xFF000000 | (red_shift << 16) | (green_shift << 8) | blue_shift;
+    RGBValue expected_average_color_shift =
+        RGBValue(red_shift, green_shift, blue_shift);
 
     EXPECT_FALSE(SendPacketAndWaitForMatch(packet.Pass(), expected_rect,
                                            expected_average_color_shift));
   }
 }
 
-uint32_t TestVideoRendererTest::CalculateAverageColorValueForFrame(
+RGBValue TestVideoRendererTest::CalculateAverageColorValueForFrame(
     const webrtc::DesktopFrame* frame,
     const webrtc::DesktopRect& rect) const {
   int red_sum = 0;
   int green_sum = 0;
   int blue_sum = 0;
 
   // Loop through pixels that fall within |accumulating_rect_| to obtain the
   // average color value.
   for (int y = rect.top(); y < rect.bottom(); ++y) {
     uint8_t* frame_pos =
         frame->data() + (y * frame->stride() +
                          rect.left() * webrtc::DesktopFrame::kBytesPerPixel);
 
     // Pixels of decoded video frame are presented in ARGB format.
     for (int x = 0; x < rect.width(); ++x) {
       red_sum += frame_pos[2];
       green_sum += frame_pos[1];
       blue_sum += frame_pos[0];
       frame_pos += 4;
     }
   }
 
   int area = rect.width() * rect.height();
-  return 0xFF000000 | ((red_sum / area) << 16) | ((green_sum / area) << 8) |
-         (blue_sum / area);
+
+  return RGBValue(red_sum / area, green_sum / area, blue_sum / area);
 }
 
 double TestVideoRendererTest::CalculateError(
     const webrtc::DesktopFrame* original_frame,
     const webrtc::DesktopFrame* decoded_frame) const {
   DCHECK(original_frame);
   DCHECK(decoded_frame);
 
   // Check size remains the same after encoding and decoding.
   EXPECT_EQ(original_frame->size().width(), decoded_frame->size().width());
@@ skipping 146 matching lines @@
       protocol::ChannelConfig::Codec::CODEC_VP8);
 
   DCHECK(encoder_);
   DCHECK(test_video_renderer_);
 
   scoped_ptr<webrtc::DesktopFrame> frame = CreateDesktopFrameWithGradient(
       kDefaultScreenWidthPx, kDefaultScreenHeightPx);
 
   // Since we don't care whether expected image pattern is matched or not in
   // this case, an expected color is chosen arbitrarily.
-  uint32_t black_color = 0xFF000000;
+  RGBValue black_color = RGBValue();
 
   // Set expected image pattern.
   test_video_renderer_->ExpectAverageColorInRect(
       kDefaultExpectedRect, black_color, base::Bind(&base::DoNothing));
 
   // Post test video packet.
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame.get());
   test_video_renderer_->ProcessVideoPacket(packet.Pass(),
                                            base::Bind(&base::DoNothing));
 }
@@ skipping 47 matching lines @@
 TEST_F(TestVideoRendererTest, VerifyImagePatternNotMatchForVERBATIM) {
   encoder_.reset(new VideoEncoderVerbatim());
   test_video_renderer_->SetCodecForDecoding(
       protocol::ChannelConfig::Codec::CODEC_VERBATIM);
   TestImagePatternMatch(kDefaultScreenWidthPx, kDefaultScreenHeightPx,
                         kDefaultExpectedRect, false);
 }
 
 }  // namespace test
 }  // namespace remoting