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

blimp/engine/session/blimp_engine_session.h

 // 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.
 
 #ifndef BLIMP_ENGINE_SESSION_BLIMP_ENGINE_SESSION_H_
 #define BLIMP_ENGINE_SESSION_BLIMP_ENGINE_SESSION_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/engine/feature/engine_render_widget_feature.h"
 #include "blimp/engine/feature/engine_settings_feature.h"
-#include "blimp/engine/session/page_load_tracker.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/connection_error_observer.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/web_contents_delegate.h"
-#include "content/public/browser/web_contents_observer.h"
 #include "net/base/completion_callback.h"
 #include "ui/base/ime/input_method_observer.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace aura {
 class WindowTreeHost;
 
 namespace client {
 class DefaultCaptureClient;
 class WindowTreeClient;
@@ skipping 27 matching lines @@
 class SettingsManager;
 
 namespace engine {
 
 class BlimpBrowserContext;
 class BlimpEngineConfig;
 class BlimpFocusClient;
 class BlimpScreen;
 class BlimpWindowTreeHost;
 class EngineNetworkComponents;
+class TabBlimp;
 
 class BlimpEngineSession
     : public BlimpMessageProcessor,
       public content::WebContentsDelegate,
-      public content::WebContentsObserver,
       public ui::InputMethodObserver,
-      public EngineRenderWidgetFeature::RenderWidgetMessageDelegate,
-      public PageLoadTrackerClient {
+      public EngineRenderWidgetFeature::RenderWidgetMessageDelegate {
  public:
   using GetPortCallback = base::Callback<void(uint16_t)>;
 
   BlimpEngineSession(std::unique_ptr<BlimpBrowserContext> browser_context,
                      net::NetLog* net_log,
                      BlimpEngineConfig* config,
                      SettingsManager* settings_manager);
   ~BlimpEngineSession() override;
 
   // Starts the network stack on the IO thread, and sets default placeholder
@@ skipping 19 matching lines @@
   // TabControlMessage handler methods.
   // Creates a new WebContents, which will be indexed by |target_tab_id|.
   // Returns true if a new WebContents is created, false otherwise.
   bool CreateWebContents(const int target_tab_id);
 
   void CloseWebContents(const int target_tab_id);
   void HandleResize(float device_pixel_ratio, const gfx::Size& size);
 
   // NavigationMessage handler methods.
   // Navigates the target tab to the |url|.
   void LoadUrl(const int target_tab_id, const GURL& url);

[Kevin M, 2016/06/02 18:38:50]

Please factor these out into a separate Navigation feature.

[haibinlu, 2016/06/02 20:24:37]

Not sure if we need separate nav feature since it is very simple. If we have a
Nav feature class, BlimpEngineSession would need to implement its delegate, and
delegate methods are these methods. We can not delegate Nav feature to tab class
directly because BlimpEngineSession need to find a tab first.

   void GoBack(const int target_tab_id);
   void GoForward(const int target_tab_id);
   void Reload(const int target_tab_id);
 
   // RenderWidgetMessage handler methods.
   // RenderWidgetMessageDelegate implementation.
   void OnWebGestureEvent(
       content::RenderWidgetHost* render_widget_host,
       std::unique_ptr<blink::WebGestureEvent> event) override;
   void OnCompositorMessageReceived(
@@ skipping 23 matching lines @@
 
   // ui::InputMethodObserver overrides.
   void OnTextInputTypeChanged(const ui::TextInputClient* client) override;
   void OnFocus() override;
   void OnBlur() override;
   void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
   void OnTextInputStateChanged(const ui::TextInputClient* client) override;
   void OnInputMethodDestroyed(const ui::InputMethod* input_method) override;
   void OnShowImeIfNeeded() override;
 
-  // content::WebContentsObserver implementation.
-  void RenderViewCreated(content::RenderViewHost* render_view_host) override;
-  void RenderViewHostChanged(content::RenderViewHost* old_host,
-                             content::RenderViewHost* new_host) override;
-  void RenderViewDeleted(content::RenderViewHost* render_view_host) override;
-
-  // PageLoadTrackerClient implementation.
-  void SendPageLoadStatusUpdate(PageLoadStatus load_status) override;
-
   // Sets up and owns |new_contents|.
-  void PlatformSetContents(std::unique_ptr<content::WebContents> new_contents);
+  void PlatformSetContents(std::unique_ptr<content::WebContents> new_contents,
+                           const int target_tab_id);
 
   // Presents the client's single screen.
   // Screen should be deleted after browser context (crbug.com/613372).
   std::unique_ptr<BlimpScreen> screen_;
 
   // Content BrowserContext for this session.
   std::unique_ptr<BlimpBrowserContext> browser_context_;
 
   // Engine configuration including assigned client token.
   BlimpEngineConfig* engine_config_;
 
   // Represents the (currently single) browser window into which tab(s) will
   // be rendered.
   std::unique_ptr<BlimpWindowTreeHost> window_tree_host_;
 
   // Used to apply standard focus conventions to the windows in the
   // WindowTreeHost hierarchy.
   std::unique_ptr<wm::FocusController> focus_client_;
 
   // Used to manage input capture.
   std::unique_ptr<aura::client::DefaultCaptureClient> capture_client_;
 
   // Used to attach null-parented windows (e.g. popups) to the root window.
   std::unique_ptr<aura::client::WindowTreeClient> window_tree_client_;
 
-  // Only one web_contents is supported for blimp 0.5
-  std::unique_ptr<content::WebContents> web_contents_;
-
-  // Tracks the page load status for a tab. Each PageLoadTracker is tied to a
-  // WebContents.
-  std::unique_ptr<PageLoadTracker> page_load_tracker_;
-
   // Manages all global settings for the engine session.
   SettingsManager* settings_manager_;
 
   // Handles all incoming messages for type SETTINGS.
-  EngineSettingsFeature settings_feature_;
+  std::unique_ptr<EngineSettingsFeature> settings_feature_;

[Kevin M, 2016/06/02 18:38:50]

Why is this a unique_ptr now?

[haibinlu, 2016/06/02 20:24:37]

reverted. I was thinking about the flexibility of deleting it at any time rather
than relying on the deconstruction order. It turns out there is no such need. 

 
   // Handles all incoming and outgoing messages related to RenderWidget,
   // including INPUT, COMPOSITOR and RENDER_WIDGET messages.
-  EngineRenderWidgetFeature render_widget_feature_;
+  std::unique_ptr<EngineRenderWidgetFeature> render_widget_feature_;

[Kevin M, 2016/06/02 18:38:50]

Ditto

[haibinlu, 2016/06/02 20:24:37]

reverted.

 
   // Container for connection manager, authentication handler, and
   // browser connection handler. The components run on the I/O thread, and
   // this object is destroyed there.
   std::unique_ptr<EngineNetworkComponents> net_components_;
 
   std::unique_ptr<ThreadPipeManager> thread_pipe_manager_;
 
   // Used to send TAB_CONTROL or NAVIGATION messages to client.
   std::unique_ptr<BlimpMessageProcessor> tab_control_message_sender_;
   std::unique_ptr<BlimpMessageProcessor> navigation_message_sender_;
 
+  // Only one tab is supported for blimp 0.5.
+  std::unique_ptr<TabBlimp> tab_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpEngineSession);
 };
 
 }  // namespace engine
 }  // namespace blimp
 
 #endif  // BLIMP_ENGINE_SESSION_BLIMP_ENGINE_SESSION_H_