Updated latency fixture and refactored connection helper

remoting/test/test_video_renderer.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/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/proto/video.pb.h"
+#include "remoting/test/rgb_value.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace {
-
-// Used to store a RGB color, and it can be converted from uint32_t.
-struct RGBValue {
-  RGBValue(int r, int g, int b) : red(r), green(g), blue(b) {}
-
-  int red;
-  int green;
-  int blue;
-};
-
-// Convert an uint32_t to a RGBValue.
-RGBValue ConvertUint32ToRGBValue(uint32_t color) {
-  RGBValue rgb_value((color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF);
-  return rgb_value;
-}
-
 // Used to account for frame resizing and lossy encoding error in percentage.
 // The average color usually only varies by 1 on each channel, so 0.01 is large
 // enough to allow variations while not being flaky for false negative cases.
 const double kMaxColorError = 0.01;
 }  // namespace
 
 namespace remoting {
 namespace test {
 
 // Implements video decoding functionality.
@@ skipping 12 matching lines @@
   // Initialize a decoder to decode video packets.
   void SetCodecForDecoding(const protocol::ChannelConfig::Codec codec);
 
   // Returns a copy of the current frame.
   scoped_ptr<webrtc::DesktopFrame> GetCurrentFrameForTest() const;
 
   // Set expected image pattern for comparison and the callback will be called
   // when the pattern is matched.
   void ExpectAverageColorInRect(
       const webrtc::DesktopRect& expected_rect,
-      uint32_t expected_avg_color,
+      const RGBValue& expected_avg_color,
       const base::Closure& image_pattern_matched_callback);
 
  private:
   // Returns average color of pixels fall within |rect| on the current frame.
   RGBValue CalculateAverageColorValue(const webrtc::DesktopRect& rect) const;
 
   // Compares |candidate_avg_value| to |expected_avg_color_|.
   // Returns true if the root mean square of the errors in the R, G and B
   // components does not exceed a given limit.
   bool ExpectedAverageColorIsMatched(const RGBValue& candidate_avg_value) const;
@@ skipping 14 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   // Used to store decoded video frame.
   scoped_ptr<webrtc::DesktopFrame> frame_;
 
   // Protects access to |frame_|.
   mutable base::Lock lock_;
 
   // Used to store the expected image pattern.
   webrtc::DesktopRect expected_rect_;
-  uint32_t expected_avg_color_;
+  RGBValue expected_avg_color_;
 
   // Used to store the callback when expected pattern is matched.
   base::Closure image_pattern_matched_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 TestVideoRenderer::Core::Core()
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   thread_checker_.DetachFromThread();
@@ skipping 101 matching lines @@
           << " " << accumulating_avg_value.blue;
 
   if (ExpectedAverageColorIsMatched(accumulating_avg_value)) {
     main_task_runner_->PostTask(
         FROM_HERE, base::ResetAndReturn(&image_pattern_matched_callback_));
   }
 }
 
 void TestVideoRenderer::Core::ExpectAverageColorInRect(
     const webrtc::DesktopRect& expected_rect,
-    uint32_t expected_avg_color,
+    const RGBValue& expected_avg_color,
     const base::Closure& image_pattern_matched_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   expected_rect_ = expected_rect;
   expected_avg_color_ = expected_avg_color;
   image_pattern_matched_callback_ = image_pattern_matched_callback;
 }
 
 RGBValue TestVideoRenderer::Core::CalculateAverageColorValue(
     const webrtc::DesktopRect& rect) const {
@@ skipping 17 matching lines @@
     }
   }
 
   int area = rect.width() * rect.height();
   RGBValue rgb_value(red_sum / area, green_sum / area, blue_sum / area);
   return rgb_value;
 }
 
 bool TestVideoRenderer::Core::ExpectedAverageColorIsMatched(
     const RGBValue& candidate_avg_value) const {
-  RGBValue expected_avg_value = ConvertUint32ToRGBValue(expected_avg_color_);
   double error_sum_squares = 0;
-  double red_error = expected_avg_value.red - candidate_avg_value.red;
-  double green_error = expected_avg_value.green - candidate_avg_value.green;
-  double blue_error = expected_avg_value.blue - candidate_avg_value.blue;
+  double red_error = expected_avg_color_.red - candidate_avg_value.red;
+  double green_error = expected_avg_color_.green - candidate_avg_value.green;
+  double blue_error = expected_avg_color_.blue - candidate_avg_value.blue;
   error_sum_squares = red_error * red_error + green_error * green_error +
                       blue_error * blue_error;
   error_sum_squares /= (255.0 * 255.0);
 
   return sqrt(error_sum_squares / 3) < kMaxColorError;
 }
 
 TestVideoRenderer::TestVideoRenderer()
     : video_decode_thread_(
         new base::Thread("TestVideoRendererVideoDecodingThread")),
@@ skipping 75 matching lines @@
 
 scoped_ptr<webrtc::DesktopFrame> TestVideoRenderer::GetCurrentFrameForTest()
     const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return core_->GetCurrentFrameForTest();
 }
 
 void TestVideoRenderer::ExpectAverageColorInRect(
     const webrtc::DesktopRect& expected_rect,
-    uint32_t expected_avg_color,
+    const RGBValue& expected_avg_color,
     const base::Closure& image_pattern_matched_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!expected_rect.is_empty()) << "Expected rect cannot be empty";
 
   DVLOG(2) << "TestVideoRenderer::SetImagePatternAndMatchedCallback() Called";
   video_decode_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Core::ExpectAverageColorInRect, base::Unretained(core_.get()),
                  expected_rect, expected_avg_color,
                  image_pattern_matched_callback));
 }
 
 }  // namespace test
 }  // namespace remoting