Added a debug info UI for Blimp

blimp/net/blimp_connection.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 "blimp/net/blimp_connection.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "blimp/common/logging.h"
 #include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/net/blimp_connection_statistics.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_pump.h"
 #include "blimp/net/common.h"
 #include "blimp/net/connection_error_observer.h"
 #include "blimp/net/packet_reader.h"
 #include "blimp/net/packet_writer.h"
 #include "net/base/completion_callback.h"
 
 namespace blimp {
 namespace {
 
 // Forwards incoming blimp messages to PacketWriter.
 class BlimpMessageSender : public BlimpMessageProcessor {
  public:
   explicit BlimpMessageSender(PacketWriter* writer);
   ~BlimpMessageSender() override;
 
   void set_error_observer(ConnectionErrorObserver* observer) {
     error_observer_ = observer;
   }
 
   // BlimpMessageProcessor implementation.
   void ProcessMessage(std::unique_ptr<BlimpMessage> message,
                       const net::CompletionCallback& callback) override;
 
+  void SetBlimpConnectionStatistics(BlimpConnectionStatistics* statistics) {
+    DCHECK(writer_);

[Kevin M, 2016/05/24 01:02:01]

Not needed - the constructor guarantees that writer_ cannot be null.

[shaktisahu, 2016/05/24 21:02:44]

Removed function since we are passing in constructor

+    writer_->set_blimp_connection_statistics(statistics);
+  }
+
  private:
   void OnWritePacketComplete(int result);
 
   PacketWriter* writer_;
   ConnectionErrorObserver* error_observer_ = nullptr;
   scoped_refptr<net::IOBuffer> buffer_;
   net::CompletionCallback pending_process_msg_callback_;
   base::WeakPtrFactory<BlimpMessageSender> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpMessageSender);
@@ skipping 55 matching lines @@
     : reader_(std::move(reader)),
       message_pump_(new BlimpMessagePump(reader_.get())),
       writer_(std::move(writer)),
       outgoing_msg_processor_(new BlimpMessageSender(writer_.get())) {
   DCHECK(writer_);
 
   // Observe the connection errors received by any of this connection's network
   // objects.
   message_pump_->set_error_observer(this);
   BlimpMessageSender* sender =
       static_cast<BlimpMessageSender*>(outgoing_msg_processor_.get());

[Kevin M, 2016/05/24 01:02:01]

You can remove this cast too, if we make outgoing_msg_processor a
BlimpMessageSender.

   sender->set_error_observer(this);
 }
 
 BlimpConnection::BlimpConnection() {}
 
 BlimpConnection::~BlimpConnection() {
   VLOG(1) << "BlimpConnection destroyed.";
 }
 
 void BlimpConnection::AddConnectionErrorObserver(
     ConnectionErrorObserver* observer) {
   error_observers_.AddObserver(observer);
 }
 
 void BlimpConnection::RemoveConnectionErrorObserver(
     ConnectionErrorObserver* observer) {
   error_observers_.RemoveObserver(observer);
 }
 
 void BlimpConnection::SetIncomingMessageProcessor(
     BlimpMessageProcessor* processor) {
   message_pump_->SetMessageProcessor(processor);
 }
 
+void BlimpConnection::SetBlimpConnectionStatistics(

[Kevin M, 2016/05/24 01:02:01]

We should be setting this at stream creation time, at the StreamPacketReader
level.

So that means:
1) have the TCPClientTransport and SSLClientTransport factories take a
BlimpConnectionStatistics*.

2) pass the pointer in to the StreamPacketReader and StreamPacketWriter objects
at creation time.

We don't have to expose any virtual getters to the packet reader or packet
writer that way, nor do we need to do any kind of two-phase initialization where
we connect and *then* we set it. A nice thing about requiring a statistics
object on construction is that we don't have to check for the existence of the
statistics object before dereferencing it - we'll know for a fact that the
statistics object is set.

+    BlimpConnectionStatistics* statistics) {
+  message_pump_->SetBlimpConnectionStatistics(statistics);
+  BlimpMessageSender* sender =
+      static_cast<BlimpMessageSender*>(outgoing_msg_processor_.get());

[Kevin M, 2016/05/24 01:02:01]

See previous comment about making outgoing_msg_processor_ a BlimpMessageSender.

+  sender->SetBlimpConnectionStatistics(statistics);
+}
+
 BlimpMessageProcessor* BlimpConnection::GetOutgoingMessageProcessor() {
   return outgoing_msg_processor_.get();
 }
 
 void BlimpConnection::OnConnectionError(int error) {
   VLOG(1) << "OnConnectionError, error=" << error;
 
   // Propagate the error to all observers.
   FOR_EACH_OBSERVER(ConnectionErrorObserver, error_observers_,
                     OnConnectionError(error));
 }
 
 }  // namespace blimp