Added a debug info UI for Blimp

blimp/client/session/blimp_client_session.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/client/session/blimp_client_session.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 55 matching lines @@
 
 }  // namespace
 
 // This class's functions and destruction are all invoked on the IO thread by
 // the BlimpClientSession.
 class ClientNetworkComponents : public ConnectionHandler,
                                 public ConnectionErrorObserver {
  public:
   // Can be created on any thread.
   explicit ClientNetworkComponents(
-      std::unique_ptr<NetworkEventObserver> observer);
+      std::unique_ptr<NetworkEventObserver> observer,
+      BlimpConnectionStatistics* blimp_connection_statistics);
   ~ClientNetworkComponents() override;
 
   // Sets up network components.
   void Initialize();
 
   // Starts the connection to the engine using the given |assignment|.
   // It is required to first call Initialize.
   void ConnectWithAssignment(const Assignment& assignment);
 
   BrowserConnectionHandler* GetBrowserConnectionHandler();
 
  private:
   // ConnectionHandler implementation.
   void HandleConnection(std::unique_ptr<BlimpConnection> connection) override;
 
   // ConnectionErrorObserver implementation.
   void OnConnectionError(int error) override;
 
   std::unique_ptr<BrowserConnectionHandler> connection_handler_;
   std::unique_ptr<ClientConnectionManager> connection_manager_;
   std::unique_ptr<NetworkEventObserver> network_observer_;
+  BlimpConnectionStatistics* connection_statistics_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientNetworkComponents);
 };
 
 ClientNetworkComponents::ClientNetworkComponents(
-    std::unique_ptr<NetworkEventObserver> network_observer)
+    std::unique_ptr<NetworkEventObserver> network_observer,
+    BlimpConnectionStatistics* statistics)
     : connection_handler_(new BrowserConnectionHandler),
-      network_observer_(std::move(network_observer)) {}
+      network_observer_(std::move(network_observer)),
+      connection_statistics_(statistics) {}
 
 ClientNetworkComponents::~ClientNetworkComponents() {}
 
 void ClientNetworkComponents::Initialize() {
   DCHECK(!connection_manager_);
   connection_manager_ = base::WrapUnique(new ClientConnectionManager(this));
 }
 
 void ClientNetworkComponents::ConnectWithAssignment(
     const Assignment& assignment) {
@@ skipping 27 matching lines @@
 BrowserConnectionHandler*
 ClientNetworkComponents::GetBrowserConnectionHandler() {
   return connection_handler_.get();
 }
 
 void ClientNetworkComponents::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
   VLOG(1) << "Connection established.";
   connection->AddConnectionErrorObserver(this);
   network_observer_->OnConnected();
+  connection->SetBlimpConnectionStatistics(connection_statistics_);
   connection_handler_->HandleConnection(std::move(connection));
 }
 
 void ClientNetworkComponents::OnConnectionError(int result) {
   VLOG(1) << "Connection error: " << net::ErrorToString(result);
   network_observer_->OnDisconnected(result);
 }
 
 BlimpClientSession::BlimpClientSession(const GURL& assigner_endpoint)
     : io_thread_("BlimpIOThread"),
       tab_control_feature_(new TabControlFeature),
       navigation_feature_(new NavigationFeature),
       ime_feature_(new ImeFeature),
       render_widget_feature_(new RenderWidgetFeature),
       settings_feature_(new SettingsFeature),
       weak_factory_(this) {
-  net_components_.reset(new ClientNetworkComponents(
-      base::WrapUnique(new CrossThreadNetworkEventObserver(
-          weak_factory_.GetWeakPtr(),
-          base::SequencedTaskRunnerHandle::Get()))));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
+  blimp_connection_statistics_.reset(new BlimpConnectionStatistics);
+  net_components_.reset(new ClientNetworkComponents(
+      base::WrapUnique(new CrossThreadNetworkEventObserver(
+          weak_factory_.GetWeakPtr(), base::SequencedTaskRunnerHandle::Get())),
+      blimp_connection_statistics_.get()));
 
   assignment_source_.reset(new AssignmentSource(
       assigner_endpoint, io_thread_.task_runner(), io_thread_.task_runner()));
 
   RegisterFeatures();
 
   // Initialize must only be posted after the RegisterFeature calls have
   // completed.
   io_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&ClientNetworkComponents::Initialize,
                             base::Unretained(net_components_.get())));
 }
 
 BlimpClientSession::~BlimpClientSession() {
   io_thread_.task_runner()->DeleteSoon(FROM_HERE, net_components_.release());
+  io_thread_.task_runner()->DeleteSoon(FROM_HERE,

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

Move ownership of the statistics object into net_components_ and just hold a
bare pointer here. BlimpNetworkComponents is a container for simplifying object
lifetime on the IO thread.

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

Done.

+                                       blimp_connection_statistics_.release());
 }
 
 void BlimpClientSession::Connect(const std::string& client_auth_token) {
   assignment_source_->GetAssignment(
       client_auth_token, base::Bind(&BlimpClientSession::ConnectWithAssignment,
                                     weak_factory_.GetWeakPtr()));
 }
 
 void BlimpClientSession::ConnectWithAssignment(AssignmentSource::Result result,
                                                const Assignment& assignment) {
@@ skipping 67 matching lines @@
 }
 
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 SettingsFeature* BlimpClientSession::GetSettingsFeature() const {
   return settings_feature_.get();
 }
 
+BlimpConnectionStatistics* BlimpClientSession::GetBlimpConnectionStatistics()
+    const {
+  return blimp_connection_statistics_.get();
+}
+
 }  // namespace client
 }  // namespace blimp