[blimp] Add support for having multiple tabs

blimp/engine/session/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/session/blimp_engine_session.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 49 matching lines @@
 #include "ui/base/ime/text_input_client.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"
 
 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 kDefaultPort = 25467;
 
 // Focus rules that support activating an child window.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
   FocusRulesImpl() {}
   ~FocusRulesImpl() override {}
@@ skipping 148 matching lines @@
       settings_manager_(settings_manager),
       settings_feature_(settings_manager_),
       render_widget_feature_(settings_manager_),
       net_components_(new EngineNetworkComponents(net_log)) {
   DCHECK(engine_config_);
   DCHECK(settings_manager_);
 
   screen_->UpdateDisplayScaleAndSize(
       kDefaultScaleFactor,
       gfx::Size(kDefaultDisplayWidth, kDefaultDisplayHeight));
-  render_widget_feature_.SetDelegate(kDummyTabId, this);
 
   std::unique_ptr<HeliumBlobSenderDelegate> helium_blob_delegate(
       new HeliumBlobSenderDelegate);
   blob_delegate_ = helium_blob_delegate.get();
   blob_channel_sender_ = base::MakeUnique<BlobChannelSenderImpl>(
       base::MakeUnique<InMemoryBlobCache>(), std::move(helium_blob_delegate));
   blob_channel_sender_weak_factory_ =
       base::MakeUnique<base::WeakPtrFactory<BlobChannelSenderImpl>>(
           blob_channel_sender_.get());
 
   device::GeolocationProvider::SetGeolocationDelegate(
       geolocation_feature_.CreateGeolocationDelegate());
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
-  render_widget_feature_.RemoveDelegate(kDummyTabId);
-
   window_tree_host_->GetInputMethod()->RemoveObserver(this);
 
   // Ensure that all tabs are torn down first, since teardown will
   // trigger RenderViewDeleted callbacks to their observers, which will in turn
   // send messages to net_components_, which is already deleted due to the line
   // below.
   tab_.reset();
 
   // Safely delete network components on the IO thread.
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
@@ skipping 111 matching lines @@
                                       const gfx::Size& size) {
   DVLOG(1) << "Resize to " << size.ToString() << ", " << device_pixel_ratio;
   screen_->UpdateDisplayScaleAndSize(device_pixel_ratio, size);
   window_tree_host_->SetBounds(gfx::Rect(size));
   if (tab_) {
     tab_->Resize(device_pixel_ratio,
                  screen_->GetPrimaryDisplay().bounds().size());
   }
 }
 
-void BlimpEngineSession::OnWebGestureEvent(
-    content::RenderWidgetHost* render_widget_host,
-    std::unique_ptr<blink::WebGestureEvent> event) {
-  TRACE_EVENT1("blimp", "BlimpEngineSession::OnWebGestureEvent", "type",
-               event->type);
-  render_widget_host->ForwardGestureEvent(*event);
-}
-
-void BlimpEngineSession::OnCompositorMessageReceived(
-    content::RenderWidgetHost* render_widget_host,
-    const std::vector<uint8_t>& message) {
-  TRACE_EVENT0("blimp", "BlimpEngineSession::OnCompositorMessageReceived");
-
-  render_widget_host->HandleCompositorProto(message);
-}
-
 void BlimpEngineSession::OnTextInputTypeChanged(
     const ui::TextInputClient* client) {}
 
 void BlimpEngineSession::OnFocus() {}
 
 void BlimpEngineSession::OnBlur() {}
 
 void BlimpEngineSession::OnCaretBoundsChanged(
     const ui::TextInputClient* client) {}
 
 // Called when either:
 //  - the TextInputClient is changed (e.g. by a change of focus)
 //  - the TextInputType of the TextInputClient changes
 void BlimpEngineSession::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
   if (!tab_ || !tab_->web_contents()->GetRenderWidgetHostView())
     return;
 
   ui::TextInputType type =
       client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
 
   // TODO(shaktisahu): Propagate the new type to the client.
   // Hide IME, when text input is out of focus, i.e. if the text input type
   // changes to ui::TEXT_INPUT_TYPE_NONE. For other text input types,
   // OnShowImeIfNeeded is used instead to send show IME request to client.
   if (type == ui::TEXT_INPUT_TYPE_NONE)
     render_widget_feature_.SendHideImeRequest(
-        kDummyTabId,
+        tab_->tab_id(),
         tab_->web_contents()->GetRenderWidgetHostView()->GetRenderWidgetHost());
 }
 
 void BlimpEngineSession::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {}
 
 // Called when a user input should trigger showing the IME.
 void BlimpEngineSession::OnShowImeIfNeeded() {
   TRACE_EVENT0("blimp", "BlimpEngineSession::OnShowImeIfNeeded");
   if (!tab_ || !tab_->web_contents()->GetRenderWidgetHostView() ||
       !window_tree_host_->GetInputMethod()->GetTextInputClient())
     return;
 
   render_widget_feature_.SendShowImeRequest(
-      kDummyTabId,
+      tab_->tab_id(),
       tab_->web_contents()->GetRenderWidgetHostView()->GetRenderWidgetHost(),
       window_tree_host_->GetInputMethod()->GetTextInputClient());
 }
 
 void BlimpEngineSession::ProcessMessage(
     std::unique_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
   TRACE_EVENT1("blimp", "BlimpEngineSession::ProcessMessage", "TabId",
                message->target_tab_id());
   DCHECK(!callback.is_null());
@@ skipping 96 matching lines @@
 }
 
 void BlimpEngineSession::ActivateContents(content::WebContents* contents) {
   contents->GetRenderViewHost()->GetWidget()->Focus();
 }
 
 void BlimpEngineSession::ForwardCompositorProto(
     content::RenderWidgetHost* render_widget_host,
     const std::vector<uint8_t>& proto) {
   TRACE_EVENT0("blimp", "BlimpEngineSession::ForwardCompositorProto");
-  render_widget_feature_.SendCompositorMessage(kDummyTabId, render_widget_host,
-                                               proto);
+  if (!tab_) {
+    return;
+  }
+  render_widget_feature_.SendCompositorMessage(tab_->tab_id(),
+                                               render_widget_host, proto);
 }
 
 void BlimpEngineSession::NavigationStateChanged(
     content::WebContents* source,
     content::InvalidateTypes changed_flags) {
   TRACE_EVENT0("blimp", "BlimpEngineSession::NavigationStateChanged");
   if (source == tab_->web_contents())
     tab_->NavigationStateChanged(changed_flags);
 }
 
 void BlimpEngineSession::PlatformSetContents(
     std::unique_ptr<content::WebContents> new_contents,
     const int target_tab_id) {
   new_contents->SetDelegate(this);
 
   aura::Window* parent = window_tree_host_->window();
   aura::Window* content = new_contents->GetNativeView();
   if (!parent->Contains(content))
     parent->AddChild(content);
   content->Show();
 
   tab_ = base::MakeUnique<Tab>(std::move(new_contents), target_tab_id,
                                &render_widget_feature_,
                                navigation_message_sender_.get());
 }
 
 }  // namespace engine
 }  // namespace blimp