[Blimp] Creates engine tab class to handle tab related operations.

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 "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/tab_control.pb.h"
 #include "blimp/engine/app/blimp_engine_config.h"
 #include "blimp/engine/app/settings_manager.h"
 #include "blimp/engine/app/switches.h"
 #include "blimp/engine/app/ui/blimp_layout_manager.h"
 #include "blimp/engine/app/ui/blimp_screen.h"
 #include "blimp/engine/app/ui/blimp_window_tree_client.h"
 #include "blimp/engine/app/ui/blimp_window_tree_host.h"
 #include "blimp/engine/common/blimp_browser_context.h"
 #include "blimp/engine/common/blimp_user_agent.h"
+#include "blimp/engine/session/tab_blimp.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_connection_statistics.h"
 #include "blimp/net/blimp_message_multiplexer.h"
 #include "blimp/net/blimp_message_thread_pipe.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"
@@ skipping 190 matching lines @@
                                      gfx::Size(kDefaultDisplayWidth,
                                                kDefaultDisplayHeight));
   render_widget_feature_.SetDelegate(kDummyTabId, this);
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
   render_widget_feature_.RemoveDelegate(kDummyTabId);
 
   window_tree_host_->GetInputMethod()->RemoveObserver(this);
 
-  page_load_tracker_.reset();
-
-  // Ensure that all WebContents are torn down first, since teardown will
+  // Ensure that all tabs are torn down first, since teardown will
   // trigger RenderViewDeleted callbacks to their observers.
-  web_contents_.reset();
+  tab_.reset();
 
   // Safely delete network components on the IO thread.
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
                                      net_components_.release());
 }
 
 void BlimpEngineSession::Initialize() {
   DCHECK(!display::Screen::GetScreen());
   display::Screen::SetScreenInstance(screen_.get());
 
@@ skipping 61 matching lines @@
   render_widget_feature_.set_ime_message_sender(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::kIme,
                                             &render_widget_feature_));
 
   // The Settings feature does not need an outgoing message processor, since we
   // don't send any messages to the client right now.
   thread_pipe_manager_->RegisterFeature(BlimpMessage::kSettings,
                                         &settings_feature_);
 }
 
-bool BlimpEngineSession::CreateWebContents(const int target_tab_id) {
+bool BlimpEngineSession::CreateTab(const int target_tab_id) {
   DVLOG(1) << "Create tab " << target_tab_id;
-  // TODO(haibinlu): Support more than one active WebContents (crbug/547231).
-  if (web_contents_) {
+  // TODO(haibinlu): Support more than one tab (crbug/547231).
+  if (tab_) {
     DLOG(WARNING) << "Tab " << target_tab_id << " already existed";
     return false;
   }
 
   content::WebContents::CreateParams create_params(browser_context_.get(),
                                                    nullptr);
   std::unique_ptr<content::WebContents> new_contents =
       base::WrapUnique(content::WebContents::Create(create_params));
-  PlatformSetContents(std::move(new_contents));
-
-  // Transfer over the user agent override. The default user agent does not
-  // have client IO info.
-  web_contents_->SetUserAgentOverride(GetBlimpEngineUserAgent());
+  PlatformSetContents(std::move(new_contents), target_tab_id);
 
   return true;
 }
 
-void BlimpEngineSession::CloseWebContents(const int target_tab_id) {
+void BlimpEngineSession::CloseTab(const int target_tab_id) {
   DVLOG(1) << "Close tab " << target_tab_id;
-  DCHECK(web_contents_);
-  web_contents_->Close();
+  tab_.reset();
 }
 
 void BlimpEngineSession::HandleResize(float device_pixel_ratio,
                                       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 (web_contents_) {
-    const gfx::Size size_in_dips = screen_->GetPrimaryDisplay().bounds().size();
-    web_contents_->GetNativeView()->SetBounds(gfx::Rect(size_in_dips));
-  }
-
-  if (web_contents_ && web_contents_->GetRenderViewHost() &&
-      web_contents_->GetRenderViewHost()->GetWidget()) {
-    web_contents_->GetRenderViewHost()->GetWidget()->WasResized();
+  if (tab_) {
+    tab_->Resize(device_pixel_ratio,
+                 screen_->GetPrimaryDisplay().bounds().size());
   }
 }
 
 void BlimpEngineSession::LoadUrl(const int target_tab_id, const GURL& url) {
-  TRACE_EVENT1("blimp", "BlimpEngineSession::LoadUrl", "URL", url.spec());
-  DVLOG(1) << "Load URL " << url << " in tab " << target_tab_id;
-  if (!url.is_valid()) {
-    VLOG(1) << "Dropping invalid URL " << url;
-    return;
-  }
-
-  // TODO(dtrainor, haibinlu): Fix up the URL with url_fixer.h.  If that doesn't
-  // produce a valid spec() then try to build a search query?
-  content::NavigationController::LoadURLParams params(url);
-  params.transition_type = ui::PageTransitionFromInt(
-      ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
-  params.override_user_agent =
-    content::NavigationController::UA_OVERRIDE_TRUE;
-  web_contents_->GetController().LoadURLWithParams(params);
-  web_contents_->Focus();
+  if (tab_)

[Kevin M, 2016/06/02 21:54:05]

I see that tab_ is already checked in the conditional that's executed
beforehand, so this should only break if there is a regresssion somewhere.
DCHECK(tab_)?

[haibinlu, 2016/06/02 23:24:33]

removed check in ProcessMessage. When multiple tab is enabled, this will lookup
tab first and check if tab is not null.

+    tab_->LoadUrl(url);
 }
 
 void BlimpEngineSession::GoBack(const int target_tab_id) {
-  DVLOG(1) << "Back in tab " << target_tab_id;
-  web_contents_->GetController().GoBack();
+  if (tab_)
+    tab_->GoBack();
 }
 
 void BlimpEngineSession::GoForward(const int target_tab_id) {
-  DVLOG(1) << "Forward in tab " << target_tab_id;
-  web_contents_->GetController().GoForward();
+  if (tab_)
+    tab_->GoForward();
 }
 
 void BlimpEngineSession::Reload(const int target_tab_id) {
-  DVLOG(1) << "Reload in tab " << target_tab_id;
-  web_contents_->GetController().Reload(true);
+  if (tab_)
+    tab_->Reload();
 }
 
 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);
 }
 
@@ skipping 13 matching lines @@
 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 (!web_contents_->GetRenderWidgetHostView())
+  if (!tab_ || !tab_->web_contents()->GetRenderWidgetHostView())

[Kevin M, 2016/06/02 21:54:05]

This is pretty severe; should we silently drop this error? Ditto for other
checks on tab_, tab_->web_contents()

Either we should DCHECK it or crash/fail the connection, but we shouldn't
silently drop the error.

[haibinlu, 2016/06/02 23:24:33]

right. checking tab_ is not necessary. if it is null, it will crash.

     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,
-        web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost());
+        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 (!web_contents_->GetRenderWidgetHostView() ||
+  if (!tab_ || !tab_->web_contents()->GetRenderWidgetHostView() ||
       !window_tree_host_->GetInputMethod()->GetTextInputClient())
     return;
 
   render_widget_feature_.SendShowImeRequest(
       kDummyTabId,
-      web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost(),
+      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());
   DCHECK(BlimpMessage::kTabControl == message->feature_case() ||
          BlimpMessage::kNavigation == message->feature_case());
 
   net::Error result = net::OK;
   if (message->has_tab_control()) {
     switch (message->tab_control().tab_control_case()) {
       case TabControlMessage::kCreateTab:
-        if (!CreateWebContents(message->target_tab_id()))
+        if (!CreateTab(message->target_tab_id()))
           result = net::ERR_FAILED;
         break;
       case TabControlMessage::kCloseTab:
-        CloseWebContents(message->target_tab_id());
+        CloseTab(message->target_tab_id());
       case TabControlMessage::kSize:
         HandleResize(message->tab_control().size().device_pixel_ratio(),
                      gfx::Size(message->tab_control().size().width(),
                                message->tab_control().size().height()));
         break;
       default:
         NOTIMPLEMENTED();
         result = net::ERR_NOT_IMPLEMENTED;
     }
-  } else if (message->has_navigation() && web_contents_) {
+  } else if (message->has_navigation() && tab_) {
     switch (message->navigation().type()) {
       case NavigationMessage::LOAD_URL:
         LoadUrl(message->target_tab_id(),
                 GURL(message->navigation().load_url().url()));
         break;
       case NavigationMessage::GO_BACK:
         GoBack(message->target_tab_id());
         break;
       case NavigationMessage::GO_FORWARD:
         GoForward(message->target_tab_id());
         break;
       case NavigationMessage::RELOAD:
         Reload(message->target_tab_id());
         break;
       default:
         NOTIMPLEMENTED();
         result = net::ERR_NOT_IMPLEMENTED;
     }
   } else {
-    DVLOG(1) << "No WebContents for navigation control";
+    DVLOG(1) << "No tab for navigation control";
     result = net::ERR_FAILED;
   }
 
   callback.Run(result);
 }
 
 void BlimpEngineSession::AddNewContents(content::WebContents* source,
                                         content::WebContents* new_contents,
                                         WindowOpenDisposition disposition,
                                         const gfx::Rect& initial_rect,
@@ skipping 28 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()) {
-    Observe(nullptr);
-    web_contents_.reset();
+  if (source == tab_->web_contents()) {

[Kevin M, 2016/06/02 21:54:05]

Is it normal behavior for this to not be true? If not, can we DCHECK this?

[haibinlu, 2016/06/02 23:24:33]

it is possible, BlimpEngineSession (future TabManagementFeature) will be the
delegate of all webcontents. thus, |source| varies.

+    tab_.reset();
   }
 }
 
 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);
 }
 
 void BlimpEngineSession::NavigationStateChanged(
     content::WebContents* source,
     content::InvalidateTypes changed_flags) {
   TRACE_EVENT0("blimp", "BlimpEngineSession::NavigationStateChanged");
-  if (source != web_contents_.get() || !changed_flags)
-    return;
-
-  NavigationMessage* navigation_message;
-  std::unique_ptr<BlimpMessage> message =
-      CreateBlimpMessage(&navigation_message, kDummyTabId);
-  navigation_message->set_type(NavigationMessage::NAVIGATION_STATE_CHANGED);
-  NavigationStateChangeMessage* details =
-      navigation_message->mutable_navigation_state_changed();
-
-  if (changed_flags & content::InvalidateTypes::INVALIDATE_TYPE_URL)
-    details->set_url(source->GetURL().spec());
-
-  if (changed_flags & content::InvalidateTypes::INVALIDATE_TYPE_TAB) {
-    // TODO(dtrainor): Serialize the favicon? crbug.com/597094.
-    DVLOG(3) << "Tab favicon changed";
-  }
-
-  if (changed_flags & content::InvalidateTypes::INVALIDATE_TYPE_TITLE)
-    details->set_title(base::UTF16ToUTF8(source->GetTitle()));
-
-  if (changed_flags & content::InvalidateTypes::INVALIDATE_TYPE_LOAD)
-    details->set_loading(source->IsLoading());
-
-  navigation_message_sender_->ProcessMessage(std::move(message),
-                                             net::CompletionCallback());
-}
-
-void BlimpEngineSession::RenderViewCreated(
-    content::RenderViewHost* render_view_host) {
-  render_widget_feature_.OnRenderWidgetCreated(kDummyTabId,
-                                               render_view_host->GetWidget());
-}
-
-void BlimpEngineSession::RenderViewHostChanged(
-    content::RenderViewHost* old_host,
-    content::RenderViewHost* new_host) {
-  // Informs client that WebContents swaps its visible RenderViewHost with
-  // another one.
-  render_widget_feature_.OnRenderWidgetInitialized(kDummyTabId,
-                                                   new_host->GetWidget());
-}
-
-void BlimpEngineSession::RenderViewDeleted(
-    content::RenderViewHost* render_view_host) {
-  render_widget_feature_.OnRenderWidgetDeleted(kDummyTabId,
-                                               render_view_host->GetWidget());
-}
-
-void BlimpEngineSession::SendPageLoadStatusUpdate(PageLoadStatus load_status) {
-  bool page_load_completed = false;
-
-  switch (load_status) {
-    case PageLoadStatus::LOADING:
-      page_load_completed = false;
-      break;
-    case PageLoadStatus::LOADED:
-      page_load_completed = true;
-      break;
-  }
-
-  NavigationMessage* navigation_message = nullptr;
-  std::unique_ptr<BlimpMessage> message =
-      CreateBlimpMessage(&navigation_message, kDummyTabId);
-  navigation_message->set_type(NavigationMessage::NAVIGATION_STATE_CHANGED);
-  NavigationStateChangeMessage* details =
-      navigation_message->mutable_navigation_state_changed();
-  details->set_page_load_completed(page_load_completed);
-
-  navigation_message_sender_->ProcessMessage(std::move(message),
-                                             net::CompletionCallback());
+  if (source == tab_->web_contents())
+    tab_->NavigationStateChanged(changed_flags);
 }
 
 void BlimpEngineSession::PlatformSetContents(
-    std::unique_ptr<content::WebContents> new_contents) {
+    std::unique_ptr<content::WebContents> new_contents,
+    const int target_tab_id) {
   new_contents->SetDelegate(this);
-  Observe(new_contents.get());
-  web_contents_ = std::move(new_contents);
 
-  page_load_tracker_.reset(new PageLoadTracker(web_contents_.get(), this));
   aura::Window* parent = window_tree_host_->window();
-  aura::Window* content = web_contents_->GetNativeView();
+  aura::Window* content = new_contents->GetNativeView();
   if (!parent->Contains(content))
     parent->AddChild(content);
   content->Show();
+
+  tab_ = base::WrapUnique(new TabBlimp(std::move(new_contents), target_tab_id,
+                                       &render_widget_feature_,
+                                       navigation_message_sender_.get()));
 }
 
 }  // namespace engine
 }  // namespace blimp