Implement video frame acknowledgements in the chromoting protocol.

remoting/protocol/message_reader.cc

 // Copyright (c) 2012 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/protocol/message_reader.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
@@ skipping 72 matching lines @@
     if (result != net::ERR_CONNECTION_CLOSED) {
       LOG(ERROR) << "Read() returned error " << result;
     }
     // Stop reading after any error.
     closed_ = true;
   }
 }
 
 void MessageReader::OnDataReceived(net::IOBuffer* data, int data_size) {
   DCHECK(CalledOnValidThread());
+
+  base::TimeTicks now = base::TimeTicks::Now();
+
+  if (message_decoder_.is_buffer_empty())
+    last_message_started_time_ = now;

[Wez, 2015/01/21 01:35:40]

nit: Blank line after this?

This logic doesn't seem correct; you're not timing from the start of the latest
message being received, but from the read buffer being empty, which is not the
same thing.

e.g. if I send three messages and received part of the first, then I start this
timer, then suppose I receive the end of the first, and the beginning of the
second, and then a delay and the rest of the second and all of the third? Then
the time I'll report for the third message will be the total time to receive all
three, which is wrong.

[Sergey Ulanov, 2015/01/29 01:33:29]

Yes, I noticed it myself too. Fixed now and updated the unittest for this case
(3 message as you described).

BTW, a cleaner way to implement this feature would be to add time tracking in
CompoundBuffer, so that it would know the time each byte was received. But I
don't think it's worth to add it there given that it's not likely to be useful
in other places.

   message_decoder_.AddData(data, data_size);
 
   // Get list of all new messages first, and then call the callback
   // for all of them.
   while (true) {
     CompoundBuffer* buffer = message_decoder_.GetNextMessage();
     if (!buffer)
       break;
     pending_messages_++;
+    base::TimeDelta read_delay = now - last_message_started_time_;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&MessageReader::RunCallback,
-                   weak_factory_.GetWeakPtr(),
-                   base::Passed(make_scoped_ptr(buffer))));
+        base::Bind(&MessageReader::RunCallback, weak_factory_.GetWeakPtr(),
+                   base::Passed(make_scoped_ptr(buffer)), read_delay));
   }
 }
 
-void MessageReader::RunCallback(scoped_ptr<CompoundBuffer> message) {
-  if (!message_received_callback_.is_null()){
+void MessageReader::RunCallback(scoped_ptr<CompoundBuffer> message,
+                                base::TimeDelta read_delay) {
+  last_message_read_delay_ = read_delay;
+  if (!message_received_callback_.is_null()) {
     message_received_callback_.Run(
         message.Pass(),
         base::Bind(&MessageReader::OnMessageDone, weak_factory_.GetWeakPtr()));
   }
 }
 
 void MessageReader::OnMessageDone() {
   DCHECK(CalledOnValidThread());
   pending_messages_--;
   DCHECK_GE(pending_messages_, 0);
 
   // Start next read if necessary.
   DoRead();
 }
 
 }  // namespace protocol
 }  // namespace remoting