Enable video stats reporting when using WebRTC

remoting/protocol/connection_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 <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 205 matching lines @@
     }
 
     run_loop.Run();
 
     if (is_using_webrtc()) {
       EXPECT_EQ(
           client_video_renderer_.GetFrameConsumer()->received_frames().size(),
           1U);
       EXPECT_EQ(
           client_video_renderer_.GetVideoStub()->received_packets().size(), 0U);
+      client_video_renderer_.GetFrameConsumer()->set_on_frame_callback(
+          base::Closure());
     } else {
       EXPECT_EQ(
           client_video_renderer_.GetFrameConsumer()->received_frames().size(),
           0U);
       EXPECT_EQ(
           client_video_renderer_.GetVideoStub()->received_packets().size(), 1U);
+      client_video_renderer_.GetVideoStub()->set_on_frame_callback(
+          base::Closure());
     }
   }
 
+  void WaitFirstFrameStats() {
+    if (!client_video_renderer_.GetFrameStatsConsumer()
+             ->received_stats()
+             .empty()) {
+      return;
+    }
+
+    base::RunLoop run_loop;
+    client_video_renderer_.GetFrameStatsConsumer()->set_on_stats_callback(
+        base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
+    run_loop.Run();
+    client_video_renderer_.GetFrameStatsConsumer()->set_on_stats_callback(
+        base::Closure());
+
+    EXPECT_FALSE(client_video_renderer_.GetFrameStatsConsumer()
+                     ->received_stats()
+                     .empty());
+  }
+
   base::MessageLoopForIO message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   MockConnectionToClientEventHandler host_event_handler_;
   MockClipboardStub host_clipboard_stub_;
   MockHostStub host_stub_;
   MockInputStub host_input_stub_;
   std::unique_ptr<ConnectionToClient> host_connection_;
   FakeSession* host_session_;  // Owned by |host_connection_|.
   bool host_connected_ = false;
@@ skipping 117 matching lines @@
   EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(event)))
       .WillOnce(DoAll(InvokeWithoutArgs(this, &ConnectionTest::DestroyHost),
                       QuitRunLoop(&run_loop)));
 
   // Send key event from the client.
   client_connection_->input_stub()->InjectKeyEvent(event);
 
   run_loop.Run();
 }
 
+TEST_P(ConnectionTest, VideoStats) {
+  // Currently this test only works for WebRTC because for ICE connections stats
+  // are reported by SoftwareVideoRenderer which is not used in this test.
+  // TODO(sergeyu): Fix this.
+  if (!is_using_webrtc())
+    return;
+
+  Connect();
+
+  base::TimeTicks start_time = base::TimeTicks::Now();
+
+  std::unique_ptr<VideoStream> video_stream =
+      host_connection_->StartVideoStream(
+          base::WrapUnique(new TestScreenCapturer()));
+
+  // Simulate an input invent injected at the start.
+  video_stream->OnInputEventReceived(start_time.ToInternalValue());
+
+  WaitFirstVideoFrame();
+
+  base::TimeTicks finish_time = base::TimeTicks::Now();
+
+  WaitFirstFrameStats();
+
+  const FrameStats& stats =
+      client_video_renderer_.GetFrameStatsConsumer()->received_stats().front();
+
+  EXPECT_TRUE(stats.host_stats.frame_size > 0);
+
+  EXPECT_TRUE(stats.host_stats.latest_event_timestamp == start_time);
+  EXPECT_TRUE(stats.host_stats.capture_delay != base::TimeDelta::Max());
+  EXPECT_TRUE(stats.host_stats.capture_overhead_delay !=
+              base::TimeDelta::Max());
+  EXPECT_TRUE(stats.host_stats.encode_delay != base::TimeDelta::Max());
+  EXPECT_TRUE(stats.host_stats.send_pending_delay != base::TimeDelta::Max());
+
+  EXPECT_FALSE(stats.client_stats.time_received.is_null());
+  EXPECT_FALSE(stats.client_stats.time_decoded.is_null());
+  EXPECT_FALSE(stats.client_stats.time_rendered.is_null());
+
+  EXPECT_TRUE(start_time + stats.host_stats.capture_pending_delay +
+                  stats.host_stats.capture_delay +
+                  stats.host_stats.capture_overhead_delay +
+                  stats.host_stats.encode_delay +
+                  stats.host_stats.send_pending_delay <=
+              stats.client_stats.time_received);
+  EXPECT_TRUE(stats.client_stats.time_received <=
+              stats.client_stats.time_decoded);
+  EXPECT_TRUE(stats.client_stats.time_decoded <=
+              stats.client_stats.time_rendered);
+  EXPECT_TRUE(stats.client_stats.time_rendered <= finish_time);
+}
+
 }  // namespace protocol
 }  // namespace remoting