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(

[Kevin M, 2016/05/20 01:02:03]

Can you move this into ClientNetworkComponents? We consciously chose to relegate
all the IO thread affine stuff into that class for simplicity's sake, so we
limit the mixing of UI thread members and IO thread members in a single object.
That makes destruction pretty error-prone.

[shaktisahu, 2016/05/22 22:36:56]

This object needs to stay closer to the UI thread since it take care of
threadsafety itself. Also it has data from both IO and UI thread. (Bytes
sent/received from IO thread while commits from UI thread). If I keep it here,
as we saw, I wouldn't have to pass asynchronous callbacks into Java and Java
code would be much simpler.

+      new BlimpConnectionStatistics(base::SequencedTaskRunnerHandle::Get()));
+  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,
+                                       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 43 matching lines @@
   // Client will not send send any RenderWidget messages, so don't save the
   // outgoing BlimpMessageProcessor in the RenderWidgetFeature.
   thread_pipe_manager_->RegisterFeature(BlimpMessage::RENDER_WIDGET,
                                         render_widget_feature_.get());
 
   ime_feature_->set_outgoing_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::IME,
                                             ime_feature_.get()));
 }
 
+void BlimpClientSession::GetDebugInfo() {
+  blimp_connection_statistics_->GetDebugInfo(base::Bind(
+      &BlimpClientSession::UpdateDebugInfo, weak_factory_.GetWeakPtr()));
+}
+
+void BlimpClientSession::UpdateDebugInfo(
+    BlimpConnectionStatistics::StatisticsMap stats) {}
+
 void BlimpClientSession::OnConnected() {}
 
 void BlimpClientSession::OnDisconnected(int result) {}
 
 TabControlFeature* BlimpClientSession::GetTabControlFeature() const {
   return tab_control_feature_.get();
 }
 
 NavigationFeature* BlimpClientSession::GetNavigationFeature() const {
   return navigation_feature_.get();
 }
 
 ImeFeature* BlimpClientSession::GetImeFeature() const {
   return ime_feature_.get();
 }
 
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 SettingsFeature* BlimpClientSession::GetSettingsFeature() const {
   return settings_feature_.get();
 }
 
+BlimpConnectionStatistics* BlimpClientSession::GetBlimpConnectionStatistics()

[Kevin M, 2016/05/20 01:02:03]

This is risky - we are exposing an IO thread member with this getter.

[shaktisahu, 2016/05/22 22:36:56]

Yea, but if it lives on UI thread and is called from UI thread, it should be
okay.

+    const {
+  return blimp_connection_statistics_.get();
+}
+
 }  // namespace client
 }  // namespace blimp