Migrate Linux Blimp client to use BlimpClientContext

blimp/client/app/linux/blimp_display_manager.cc

Index: blimp/client/app/linux/blimp_display_manager.cc
diff --git a/blimp/client/app/linux/blimp_display_manager.cc b/blimp/client/app/linux/blimp_display_manager.cc
index 5997c4d967aeb835cdcf124de341991e4b649801..e80b2f96a9693cd7fcf34e46f6208c0d818a90b1 100644
--- a/blimp/client/app/linux/blimp_display_manager.cc
+++ b/blimp/client/app/linux/blimp_display_manager.cc
@@ -4,12 +4,12 @@
 
 #include "blimp/client/app/linux/blimp_display_manager.h"
 
+#include "base/memory/ptr_util.h"
 #include "blimp/client/app/compositor/browser_compositor.h"
-#include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
-#include "blimp/client/core/compositor/blimp_compositor_manager.h"
-#include "blimp/client/core/contents/tab_control_feature.h"
-#include "blimp/client/core/render_widget/render_widget_feature.h"
-#include "blimp/client/support/compositor/compositor_dependencies_impl.h"
+#include "blimp/client/public/compositor/compositor_dependencies.h"
+#include "blimp/client/public/contents/blimp_contents.h"
+#include "blimp/client/public/contents/blimp_contents_view.h"
+#include "blimp/client/public/contents/blimp_navigation_controller.h"
 #include "ui/events/event.h"
 #include "ui/events/gesture_detection/motion_event_generic.h"
 #include "ui/events/gestures/motion_event_aura.h"
@@ -19,7 +19,6 @@
 
 namespace blimp {
 namespace {
-constexpr int kDummyBlimpContentsId = 0;
 constexpr int kPointer1Id = 0;
 constexpr int kPointer2Id = 1;
 constexpr int kZoomOffsetMultiplier = 4;
@@ -30,38 +29,27 @@ namespace client {
 BlimpDisplayManager::BlimpDisplayManager(
     const gfx::Size& window_size,
     BlimpDisplayManagerDelegate* delegate,
-    RenderWidgetFeature* render_widget_feature,
-    TabControlFeature* tab_control_feature)
+    CompositorDependencies* compositor_dependencies,
+    std::unique_ptr<BlimpContents> contents)
     : device_pixel_ratio_(1.f),
       delegate_(delegate),
-      tab_control_feature_(tab_control_feature),
+      contents_(std::move(contents)),
       platform_window_(new ui::X11Window(this)) {
-  platform_window_->SetBounds(gfx::Rect(window_size));
-
-  compositor_dependencies_ = base::MakeUnique<BlimpCompositorDependencies>(
-      base::MakeUnique<CompositorDependenciesImpl>());
-
-  compositor_ = base::MakeUnique<BrowserCompositor>(
-      compositor_dependencies_->GetEmbedderDependencies());
-  compositor_->SetSize(platform_window_->GetBounds().size());
+  compositor_ = base::MakeUnique<BrowserCompositor>(compositor_dependencies);
 
-  compositor_manager_ = base::MakeUnique<BlimpCompositorManager>(
-      kDummyBlimpContentsId, render_widget_feature,
-      compositor_dependencies_.get());
+  platform_window_->SetBounds(gfx::Rect(window_size));

[Kevin M, 2016/09/27 21:59:41]

This is a strange ctor side effect - any reason why the caller can't set the
size?

Also, this ctor looks like it's doing more heavy lifting than just
initialization. Please look at this style rule:
https://google.github.io/styleguide/cppguide.html#Doing_Work_in_Constructors

[steimel, 2016/09/27 23:23:19]

As part of the initialization of the display manager, it needs to create and
initialize its X11 platform window. The three parts of this are creating the new
window, setting its size to the size provided by the caller as the first
argument, and making it visible. Perhaps we could move some/all of this
initialization to a separate method for the caller to call (e.g.
display_manager.Start/ShowWindow/SetupWindow/Whatever), but I'm not entirely
sure where you'd like that split to occur

[David Trainor- moved to gerrit, 2016/09/28 16:34:01]

Suggested split:

Pull out a SetWindowSize() and SetBlimpContents() on BlimpDisplayManager.  Just
call those two after initializing the object.  Check that calling
platform_window_->SetBounds() properly triggers OnBoundsChanged() to the
delegate.  If so you don't have to call OnBoundsChanged in the constructor (or
anywhere else explicitly).

The only annoying thing is you'll have to DCHECK or null check use of contents_
everywhere else in the class.

[steimel, 2016/09/28 20:33:07]

Done.

+  OnBoundsChanged(platform_window_->GetBounds());
 
-  compositor_->SetContentLayer(compositor_manager_->layer());
+  compositor_->SetContentLayer(contents_->GetView()->GetLayer());
 
   platform_window_->Show();
-
-  tab_control_feature_->SetSizeAndScale(platform_window_->GetBounds().size(),
-                                        device_pixel_ratio_);
 }
 
 BlimpDisplayManager::~BlimpDisplayManager() {}
 
 void BlimpDisplayManager::OnBoundsChanged(const gfx::Rect& new_bounds) {
   compositor_->SetSize(new_bounds.size());
-  tab_control_feature_->SetSizeAndScale(new_bounds.size(), device_pixel_ratio_);
+  contents_->GetView()->SetSizeAndScale(new_bounds.size(), device_pixel_ratio_);
 }
 
 void BlimpDisplayManager::DispatchEvent(ui::Event* event) {
@@ -81,7 +69,7 @@ void BlimpDisplayManager::DispatchMotionEventAura(
   touch_event_stream->OnTouch(
       ui::TouchEvent(event_type, gfx::Point(pointer_x, pointer_y), pointer_id,
                      base::TimeTicks::Now()));
-  compositor_manager_->OnTouchEvent(*touch_event_stream);
+  contents_->GetView()->OnTouchEvent(*touch_event_stream);
 }
 
 void BlimpDisplayManager::DispatchMouseWheelEvent(
@@ -148,12 +136,12 @@ void BlimpDisplayManager::DispatchMouseEvent(ui::MouseEvent* mouse_event) {
                                            0);
     ui::MotionEventGeneric motion_event(action, mouse_event->time_stamp(),
                                         mouse_properties);
-    compositor_manager_->OnTouchEvent(motion_event);
+    contents_->GetView()->OnTouchEvent(motion_event);
   }
 }
 
 void BlimpDisplayManager::OnCloseRequest() {
-  compositor_manager_->SetVisible(false);
+  contents_->Hide();
   compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
   platform_window_->Close();
 }
@@ -167,17 +155,17 @@ void BlimpDisplayManager::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_pixel_ratio) {
   device_pixel_ratio_ = device_pixel_ratio;
-  tab_control_feature_->SetSizeAndScale(platform_window_->GetBounds().size(),
+  contents_->GetView()->SetSizeAndScale(platform_window_->GetBounds().size(),
                                         device_pixel_ratio_);
 
   if (widget != gfx::kNullAcceleratedWidget) {
-    compositor_manager_->SetVisible(true);
+    contents_->Show();
     compositor_->SetAcceleratedWidget(widget);
   }
 }
 
 void BlimpDisplayManager::OnAcceleratedWidgetDestroyed() {
-  compositor_manager_->SetVisible(false);
+  contents_->Hide();
   compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
 }