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/strings/utf_string_conversions.h"
 #include "blimp/common/create_blimp_message.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_t kDefaultPortNumber = 25467;
+const uint16_t kDefaultPort = 25467;
 
 // 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);
 };
 
+net::IPAddressNumber GetIPv4AnyAddress() {
+  net::IPAddressNumber output;
+  output.push_back(0);
+  output.push_back(0);
+  output.push_back(0);
+  output.push_back(0);
+  return output;
+}
+
 }  // namespace
 
 // This class's functions and destruction are all invoked on the IO thread by
 // the BlimpEngineSession.
-class BlimpNetworkComponents {
+class EngineNetworkComponents {
  public:
-  explicit BlimpNetworkComponents(net::NetLog* net_log);
-  ~BlimpNetworkComponents();
+  explicit EngineNetworkComponents(net::NetLog* net_log);
+  ~EngineNetworkComponents();
 
   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);
+  DISALLOW_COPY_AND_ASSIGN(EngineNetworkComponents);
 };
 
-BlimpNetworkComponents::BlimpNetworkComponents(net::NetLog* net_log)
+EngineNetworkComponents::EngineNetworkComponents(net::NetLog* net_log)
     : net_log_(net_log) {}
 
-BlimpNetworkComponents::~BlimpNetworkComponents() {
+EngineNetworkComponents::~EngineNetworkComponents() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
-void BlimpNetworkComponents::Initialize() {
+void EngineNetworkComponents::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);
+  net::IPEndPoint address(GetIPv4AnyAddress(), kDefaultPort);
   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),
-      net_components_(new BlimpNetworkComponents(net_log)) {
+      net_components_(new EngineNetworkComponents(net_log)) {
   screen_->UpdateDisplayScaleAndSize(kDefaultScaleFactor,
                                      gfx::Size(kDefaultDisplayWidth,
                                                kDefaultDisplayHeight));
   render_widget_feature_.SetDelegate(kDummyTabId, this);
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
   render_widget_feature_.RemoveDelegate(kDummyTabId);
 
   // Safely delete network components on the IO thread.
@@ skipping 26 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::Bind(&EngineNetworkComponents::Initialize,
                  base::Unretained(net_components_.get())));
 
-  // Registers features.
-  // TODO(kmarshall) Refactor this using
-  //  1. Get outgoing message processors for blimp message types of a feature.
-  //  2. Create a feature with these outgoing message processors.
-  //  3. Register the feature as the incoming message processor for these
-  //     blimp message types.
+  // Register features' message senders and receivers.
   tab_control_message_sender_ =
       RegisterFeature(BlimpMessage::TAB_CONTROL, this);
   navigation_message_sender_ = RegisterFeature(BlimpMessage::NAVIGATION, this);
-
   render_widget_feature_.set_render_widget_message_sender(
       RegisterFeature(BlimpMessage::RENDER_WIDGET, &render_widget_feature_));
   render_widget_feature_.set_input_message_sender(
       RegisterFeature(BlimpMessage::INPUT, &render_widget_feature_));
   render_widget_feature_.set_compositor_message_sender(
       RegisterFeature(BlimpMessage::COMPOSITOR, &render_widget_feature_));
 }
 
 scoped_ptr<BlimpMessageProcessor> BlimpEngineSession::RegisterFeature(
     BlimpMessage::Type type,
@@ skipping 241 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