Add glue between the client and engine for Blimp

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 "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/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/null_blimp_message_processor.h"
 #include "content/public/browser/browser_context.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"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/core/focus_controller.h"
 
 #if !defined(USE_X11)
 #include "blimp/engine/ui/blimp_window_tree_host.h"
 #endif
 
 namespace blimp {
 namespace engine {
 namespace {
 
+const int kDummyTabId = 0;
+
+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
 
 BlimpEngineSession::BlimpEngineSession(
     scoped_ptr<BlimpBrowserContext> browser_context)
-    : browser_context_(std::move(browser_context)), screen_(new BlimpScreen) {}
+    : 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()) {
+  render_widget_processor_.SetDelegate(kDummyTabId, this);
+}
 
-BlimpEngineSession::~BlimpEngineSession() {}
+BlimpEngineSession::~BlimpEngineSession() {
+  render_widget_processor_.RemoveDelegate(kDummyTabId);
+}
 
 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
   context_factory_.reset(new BlimpUiContextFactory());
@@ skipping 27 matching lines @@
   scoped_ptr<content::WebContents> new_contents =
       make_scoped_ptr(content::WebContents::Create(create_params));
   PlatformSetContents(std::move(new_contents));
 }
 
 void BlimpEngineSession::CloseWebContents(const int target_tab_id) {
   DCHECK(web_contents_);
   web_contents_->Close();
 }
 
+void BlimpEngineSession::HandleResize(const gfx::Size& size) {
+  // TODO(dtrainor, haibinlu): Set the proper size on the WebContents/save for
+  // future WebContents objects.
+}
+
 void BlimpEngineSession::LoadUrl(const int target_tab_id, const GURL& url) {
   if (url.is_empty() || !web_contents_)
     return;
 
   content::NavigationController::LoadURLParams params(url);
   params.transition_type = ui::PageTransitionFromInt(
       ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
   web_contents_->GetController().LoadURLWithParams(params);
   web_contents_->Focus();
 }
@@ skipping 12 matching lines @@
   web_contents_->GetController().GoForward();
 }
 
 void BlimpEngineSession::Reload(const int target_tab_id) {
   if (!web_contents_)
     return;
 
   web_contents_->GetController().Reload(true);
 }
 
+void BlimpEngineSession::OnWebInputEvent(
+    scoped_ptr<blink::WebInputEvent> event) {
+  if (!web_contents_ || !web_contents_->GetRenderViewHost())
+    return;
+
+  // TODO(dtrainor): Send the input event directly to the render process?
+}
+
+void BlimpEngineSession::OnCompositorMessageReceived(
+    const std::vector<uint8_t>& message) {
+  // Make sure that We actually have a valid WebContents and RenderViewHost.
+  if (!web_contents_ || !web_contents_->GetRenderViewHost())
+    return;
+
+  content::RenderWidgetHost* host =
+      web_contents_->GetRenderViewHost()->GetWidget();
+
+  // 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) {
   DCHECK(message->type() == BlimpMessage::CONTROL ||
-      message->type() == BlimpMessage::NAVIGATION ||
-      message->type() == BlimpMessage::COMPOSITOR);
+      message->type() == BlimpMessage::NAVIGATION);
 
   if (message->type() == BlimpMessage::CONTROL) {
     switch (message->control().type()) {
       case ControlMessage::CREATE_TAB:
         CreateWebContents(message->target_tab_id());
         break;
       case ControlMessage::CLOSE_TAB:
         CloseWebContents(message->target_tab_id());
+      case ControlMessage::SIZE:
+        HandleResize(gfx::Size(message->control().resize().width(),
+                               message->control().resize().height()));
+        break;
       default:
         NOTIMPLEMENTED();
     }
   } else if (message->type() == BlimpMessage::NAVIGATION && web_contents_) {
     switch (message->navigation().type()) {
       case NavigationMessage::LOAD_URL:
         LoadUrl(message->target_tab_id(),
                 GURL(message->navigation().load_url().url()));
         break;
       case NavigationMessage::GO_BACK:
@@ skipping 58 matching lines @@
   return source;
 }
 
 void BlimpEngineSession::RequestToLockMouse(content::WebContents* web_contents,
                                             bool user_gesture,
                                             bool last_unlocked_by_target) {
   web_contents->GotResponseToLockMouseRequest(true);
 }
 
 void BlimpEngineSession::CloseContents(content::WebContents* source) {
-  if (source == web_contents_.get())
+  if (source == web_contents_.get()) {
+    Observe(nullptr);
     web_contents_.reset();
+  }
 }
 
 void BlimpEngineSession::ActivateContents(content::WebContents* contents) {
   contents->GetRenderViewHost()->GetWidget()->Focus();
 }
 
 void BlimpEngineSession::ForwardCompositorProto(
     const std::vector<uint8_t>& proto) {
-  // Send the compositor proto over the network layer to the client, which will
-  // apply the proto to their local compositor instance.
-  // TODO(dtrainor): Send the compositor proto.
+  render_widget_processor_.SendCompositorMessage(kDummyTabId, proto);
+}
+
+void BlimpEngineSession::RenderViewHostChanged(
+    content::RenderViewHost* old_host,
+    content::RenderViewHost* new_host) {
+  render_widget_processor_.OnRenderWidgetInitialized(kDummyTabId);
 }
 
 void BlimpEngineSession::PlatformSetContents(
     scoped_ptr<content::WebContents> new_contents) {
   new_contents->SetDelegate(this);
+  Observe(new_contents.get());
   web_contents_ = std::move(new_contents);
 
   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