Migrate Linux Blimp client to use BlimpClientContext

blimp/client/app/linux/blimp_display_manager.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/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"
 #include "ui/gfx/geometry/size.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/x11/x11_window.h"
 
 namespace blimp {
 namespace {
-constexpr int kDummyBlimpContentsId = 0;
 constexpr int kPointer1Id = 0;
 constexpr int kPointer2Id = 1;
 constexpr int kZoomOffsetMultiplier = 4;
 }  // namespace
 
 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)) {
+  compositor_ = base::MakeUnique<BrowserCompositor>(compositor_dependencies);
+
   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_dependencies_ = base::MakeUnique<BlimpCompositorDependencies>(
-      base::MakeUnique<CompositorDependenciesImpl>());
-
-  compositor_ = base::MakeUnique<BrowserCompositor>(
-      compositor_dependencies_->GetEmbedderDependencies());
-  compositor_->SetSize(platform_window_->GetBounds().size());
-
-  compositor_manager_ = base::MakeUnique<BlimpCompositorManager>(
-      kDummyBlimpContentsId, render_widget_feature,
-      compositor_dependencies_.get());
-
-  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) {
   if (event->IsMouseWheelEvent()) {
     DispatchMouseWheelEvent(event->AsMouseWheelEvent());
   } else if (event->IsMouseEvent()) {
     DispatchMouseEvent(event->AsMouseEvent());
   }
 }
 
 void BlimpDisplayManager::DispatchMotionEventAura(
     ui::MotionEventAura* touch_event_stream,
     ui::EventType event_type,
     int pointer_id,
     int pointer_x,
     int pointer_y) {
   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(
     ui::MouseWheelEvent* wheel_event) {
   // In order to better simulate the Android experience on the Linux client
   // we convert mousewheel scrolling events into pinch/zoom events.
   bool zoom_out = wheel_event->y_offset() < 0;
   Zoom(wheel_event->x(), wheel_event->y(), wheel_event->y_offset(), zoom_out);
 }
 
@@ skipping 46 matching lines @@
 
 void BlimpDisplayManager::DispatchMouseEvent(ui::MouseEvent* mouse_event) {
   ui::MotionEvent::Action action = MouseEventToAction(mouse_event);
 
   if (action != ui::MotionEvent::ACTION_NONE &&
       mouse_event->IsOnlyLeftMouseButton()) {
     ui::PointerProperties mouse_properties(mouse_event->x(), mouse_event->y(),
                                            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();
 }
 
 void BlimpDisplayManager::OnClosed() {
   if (delegate_)
     delegate_->OnClosed();
 }
 
 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);
 }
 
 }  // namespace client
 }  // namespace blimp