Implementation and fixes for Blimp client/engine E2E communication.

blimp/engine/browser/blimp_engine_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/engine/browser/blimp_engine_session.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/tab_control.pb.h"
 #include "blimp/engine/browser/blimp_browser_context.h"
 #include "blimp/engine/ui/blimp_layout_manager.h"
 #include "blimp/engine/ui/blimp_screen.h"
 #include "blimp/engine/ui/blimp_ui_context_factory.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_message_multiplexer.h"
 #include "blimp/net/browser_connection_handler.h"
+#include "blimp/net/common.h"
 #include "blimp/net/engine_authentication_handler.h"
 #include "blimp/net/engine_connection_manager.h"
 #include "blimp/net/null_blimp_message_processor.h"
 #include "blimp/net/tcp_engine_transport.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
@@ skipping 13 matching lines @@
 #endif
 
 namespace blimp {
 namespace engine {
 namespace {
 
 const int kDummyTabId = 0;
 const float kDefaultScaleFactor = 1.f;
 const int kDefaultDisplayWidth = 800;
 const int kDefaultDisplayHeight = 600;
-const uint16 kDefaultPortNumber = 25467;
 
 base::LazyInstance<blimp::NullBlimpMessageProcessor> g_blimp_message_processor =
     LAZY_INSTANCE_INITIALIZER;
 
 // Focus rules that support activating an child window.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
   FocusRulesImpl() {}
   ~FocusRulesImpl() override {}
 
   bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusRulesImpl);
 };
 
 }  // namespace
 
-// This class's functions and destruction are all invoked on the IO thread by
-// the BlimpEngineSession.
-class BlimpNetworkComponents {

[haibinlu, 2015/12/29 00:51:45]

per offline discussion, keep BlimpNetworkComponents

[Kevin M, 2015/12/30 23:08:49]

Done.

- public:
-  explicit BlimpNetworkComponents(net::NetLog* net_log);
-  ~BlimpNetworkComponents();
-
-  void Initialize();
-
- private:
-  net::NetLog* net_log_;
-  scoped_ptr<BrowserConnectionHandler> connection_handler_;
-  scoped_ptr<EngineAuthenticationHandler> authentication_handler_;
-  scoped_ptr<EngineConnectionManager> connection_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(BlimpNetworkComponents);
-};
-
-BlimpNetworkComponents::BlimpNetworkComponents(net::NetLog* net_log)
-    : net_log_(net_log) {}
-
-BlimpNetworkComponents::~BlimpNetworkComponents() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-}
-
-void BlimpNetworkComponents::Initialize() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  DCHECK(!connection_handler_);
-
-  // Creates and connects net components.
-  // A BlimpConnection flows from
-  // connection_manager_ --> authentication_handler_ --> connection_handler_
-  connection_handler_.reset(new BrowserConnectionHandler);
-  authentication_handler_.reset(
-      new EngineAuthenticationHandler(connection_handler_.get()));
-  connection_manager_.reset(
-      new EngineConnectionManager(authentication_handler_.get()));
-
-  // Adds BlimpTransports to connection_manager_.
-  net::IPAddressNumber local_ip_any;
-  bool success = net::ParseIPLiteralToNumber("0.0.0.0", &local_ip_any);
-  DCHECK(success);
-  net::IPEndPoint address(local_ip_any, kDefaultPortNumber);
-  connection_manager_->AddTransport(
-      make_scoped_ptr(new TCPEngineTransport(address, net_log_)));
-}
-
 BlimpEngineSession::BlimpEngineSession(
     scoped_ptr<BlimpBrowserContext> browser_context,
     net::NetLog* net_log)
     : browser_context_(std::move(browser_context)),
       screen_(new BlimpScreen),
       // TODO(dtrainor, haibinlu): Properly pull these from the BlimpMessageMux.
       render_widget_processor_(g_blimp_message_processor.Pointer(),
                                g_blimp_message_processor.Pointer()),
-      net_components_(new BlimpNetworkComponents(net_log)) {
+      net_log_(net_log) {
   screen_->UpdateDisplayScaleAndSize(kDefaultScaleFactor,
                                      gfx::Size(kDefaultDisplayWidth,
                                                kDefaultDisplayHeight));
   render_widget_processor_.SetDelegate(kDummyTabId, this);
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
   render_widget_processor_.RemoveDelegate(kDummyTabId);
 
   // Safely delete network components on the IO thread.
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
-                                     net_components_.release());
+                                     connection_handler_.release());
+  content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
+                                     authentication_handler_.release());
+  content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
+                                     connection_manager_.release());
 }
 
 void BlimpEngineSession::Initialize() {
   DCHECK(!gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE));
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
 
 #if defined(USE_X11)
   window_tree_host_.reset(aura::WindowTreeHost::Create(
       gfx::Rect(screen_->GetPrimaryDisplay().size())));
 #else
@@ skipping 14 matching lines @@
       new aura::client::DefaultCaptureClient(window_tree_host_->window()));
 
 #if defined(USE_X11)
   window_tree_host_->Show();
 #endif
 
   window_tree_host_->SetBounds(gfx::Rect(screen_->GetPrimaryDisplay().size()));
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&BlimpNetworkComponents::Initialize,
-                 base::Unretained(net_components_.get())));
+      base::Bind(&BlimpEngineSession::InitializeNetwork,
+                 base::Unretained(this)));
 }
 
 void BlimpEngineSession::CreateWebContents(const int target_tab_id) {
   // TODO(haibinlu): Support more than one active WebContents (crbug/547231).
   DCHECK(!web_contents_);
   content::WebContents::CreateParams create_params(browser_context_.get(),
                                                    nullptr);
   scoped_ptr<content::WebContents> new_contents =
       make_scoped_ptr(content::WebContents::Create(create_params));
   PlatformSetContents(std::move(new_contents));
@@ skipping 67 matching lines @@
   // Make sure we actually have a valid RenderWidgetHost.
   if (!host)
     return;
 
   host->HandleCompositorProto(message);
 }
 
 void BlimpEngineSession::ProcessMessage(
     scoped_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
+  DVLOG(2) << "BlimpEngineSession: ProcessMessage";
   DCHECK(message->type() == BlimpMessage::TAB_CONTROL ||
          message->type() == BlimpMessage::NAVIGATION);
 
   if (message->type() == BlimpMessage::TAB_CONTROL) {
     switch (message->tab_control().type()) {
       case TabControlMessage::CREATE_TAB:
         CreateWebContents(message->target_tab_id());
         break;
       case TabControlMessage::CLOSE_TAB:
         CloseWebContents(message->target_tab_id());
@@ skipping 23 matching lines @@
       default:
         NOTIMPLEMENTED();
     }
   }
 
   if (!callback.is_null()) {
     callback.Run(net::OK);
   }
 }
 
+void BlimpEngineSession::InitializeNetwork() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(!connection_handler_);
+
+  // Create a handler chain for BlimpConnections.
+  // Newly connected BlimpConnections are passed from
+  // connection_manager_ --> authentication_handler_ --> connection_handler_.
+  connection_handler_.reset(new BrowserConnectionHandler);
+  authentication_handler_.reset(
+      new EngineAuthenticationHandler(connection_handler_.get()));
+  connection_manager_.reset(
+      new EngineConnectionManager(authentication_handler_.get()));
+
+  // Adds BlimpTransports to connection_manager_.
+  // TODO(kmarshall): Take transport configuration from parameters.
+  net::IPAddressNumber local_ip_any;
+  bool success = net::ParseIPLiteralToNumber("0.0.0.0", &local_ip_any);
+  CHECK(success);
+  net::IPEndPoint address(local_ip_any, kDefaultTcpPort);
+  connection_manager_->AddTransport(
+      make_scoped_ptr(new TCPEngineTransport(address, net_log_)));
+}
+
 void BlimpEngineSession::AddNewContents(content::WebContents* source,
                                         content::WebContents* new_contents,
                                         WindowOpenDisposition disposition,
                                         const gfx::Rect& initial_rect,
                                         bool user_gesture,
                                         bool* was_blocked) {
   NOTIMPLEMENTED();
 }
 
 content::WebContents* BlimpEngineSession::OpenURLFromTab(
@@ skipping 99 matching lines @@
 
   aura::Window* parent = window_tree_host_->window();
   aura::Window* content = web_contents_->GetNativeView();
   if (!parent->Contains(content))
     parent->AddChild(content);
   content->Show();
 }
 
 }  // namespace engine
 }  // namespace blimp