blimp: Move compositing, input and render widget feature to client/core.

blimp/client/core/render_widget/blimp_render_widget.cc

Index: blimp/client/core/render_widget/blimp_render_widget.cc
diff --git a/blimp/client/core/render_widget/blimp_render_widget.cc b/blimp/client/core/render_widget/blimp_render_widget.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8584df12164e280f646e3ece273a91383da67082
--- /dev/null
+++ b/blimp/client/core/render_widget/blimp_render_widget.cc
@@ -0,0 +1,171 @@
+// Copyright 2016 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/core/render_widget/blimp_render_widget.h"
+
+#include "base/logging.h"
+#include "blimp/client/core/compositor/blob_image_serialization_processor.h"
+#include "blimp/client/core/compositor/compositor_deps_provider.h"
+#include "blimp/client/core/render_widget/blimp_render_widget_delegate.h"
+#include "blimp/net/blimp_stats.h"
+#include "cc/proto/compositor_message.pb.h"
+
+namespace blimp {
+namespace client {
+
+class BlimpRenderWidget::DirectRenderingDeps {
+ public:
+  explicit DirectRenderingDeps(BlimpRenderWidget* render_widget)
+      : render_widget_(render_widget),
+        window_(gfx::kNullAcceleratedWidget),
+        visible_(false),
+        output_surface_request_pending_(false) {
+    DCHECK(render_widget_);
+  }
+
+  ~DirectRenderingDeps() = default;
+
+  void SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
+    if (widget == gfx::kNullAcceleratedWidget &&
+        window_ == gfx::kNullAcceleratedWidget) {
+      return;
+    }
+
+    // If we did not have a widget, the compositor should not be visible.
+    DCHECK(window_ != gfx::kNullAcceleratedWidget ||
+           !render_widget_->compositor_->IsVisible());
+
+    // Release any references to the old widget.
+    UpdateVisibility(false);
+
+    window_ = widget;
+    UpdateVisibility(visible_ && window_ != gfx::kNullAcceleratedWidget);
+  }
+
+  void SetVisible(bool visible) {
+    visible_ = visible;
+    UpdateVisibility(visible_ && window_ != gfx::kNullAcceleratedWidget);
+  }
+
+  void RequestOutputSurface() {
+    DCHECK(!output_surface_request_pending_);
+    output_surface_request_pending_ = true;
+    HandlePendingOutputSurfaceRequest();
+  }
+
+ private:
+  void HandlePendingOutputSurfaceRequest() {
+    if (!output_surface_request_pending_) {
+      return;
+    }
+
+    render_widget_->compositor_->SetOutputSurface(
+        render_widget_->compositor_deps_provider_->CreateDelegatedOutputSurface(
+            window_));
+
+    output_surface_request_pending_ = false;
+  }
+
+  void UpdateVisibility(bool visible) {
+    if (visible) {
+      render_widget_->compositor_->SetVisible(true);
+      HandlePendingOutputSurfaceRequest();
+    } else {
+      render_widget_->compositor_->SetVisible(false);
+      render_widget_->compositor_->ReleaseOutputSurface();
+    }
+  }
+
+  BlimpRenderWidget* render_widget_;
+
+  gfx::AcceleratedWidget window_;
+  bool visible_;
+
+  // Whether there is an OutputSurface request pending from the current
+  // compositor. Becomes |true| if RequestOutputSurface is called, and |false|
+  // if compositor is deleted or we succeed in creating an OutputSurface.
+  bool output_surface_request_pending_;
+};
+
+BlimpRenderWidget::BlimpRenderWidget(
+    int32_t render_widget_id,
+    CompositorDepsProvider* compositor_deps_provider,
+    BlimpRenderWidgetDelegate* delegate)
+    : render_widget_id_(render_widget_id),
+      compositor_deps_provider_(compositor_deps_provider),
+      delegate_(delegate) {
+  DCHECK(delegate_);
+
+  compositor_ = base::MakeUnique<BlimpCompositor>(
+      compositor_deps_provider->GetTaskGraphRunner(),
+      compositor_deps_provider_->GetGpuMemoryBufferManager(),
+      BlobImageSerializationProcessor::current(),
+      compositor_deps_provider_->GetLayerTreeSettings(),
+      compositor_deps_provider_->GetCompositorTaskRunner(), this);
+
+  if (compositor_deps_provider_->use_internal_display()) {
+    direct_rendering_deps_ = base::MakeUnique<DirectRenderingDeps>(this);
+  }
+}
+
+BlimpRenderWidget::~BlimpRenderWidget() {}
+
+int32_t BlimpRenderWidget::GetId() const {
+  return render_widget_id_;
+}
+
+void BlimpRenderWidget::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
+  DCHECK(direct_rendering_deps_);
+  direct_rendering_deps_->SetAcceleratedWidget(widget);
+}
+
+void BlimpRenderWidget::SetVisible(bool visible) {
+  if (direct_rendering_deps_) {
+    direct_rendering_deps_->SetVisible(visible);
+  } else {
+    compositor_->SetVisible(visible);
+  }
+}
+
+// Move to the BlimpRenderWidgetView.
+bool BlimpRenderWidget::OnTouchEvent(const ui::MotionEvent& motion_event) {
+  if (compositor_->input_manager()) {
+    return compositor_->input_manager()->OnTouchEvent(motion_event);
+  }
+  return false;
+}
+
+void BlimpRenderWidget::OnCompositorMessageReceived(
+    std::unique_ptr<cc::proto::CompositorMessage> message) {
+  compositor_->OnCompositorMessageReceived(std::move(message));
+}
+
+void BlimpRenderWidget::DidCompleteSwapBuffers() {
+  delegate_->CompositorDidCompleteSwapBuffers();
+}
+
+void BlimpRenderWidget::DidCommitAndDrawFrame() {
+  BlimpStats::GetInstance()->Add(BlimpStats::EventType::COMMIT, 1);
+}
+
+void BlimpRenderWidget::SendWebGestureEvent(
+    const blink::WebGestureEvent& gesture_event) {
+  delegate_->SendWebGestureEvent(this, gesture_event);
+}
+
+void BlimpRenderWidget::SendCompositorMessage(
+    const cc::proto::CompositorMessage& message) {
+  delegate_->SendCompositorMessage(this, message);
+}
+
+void BlimpRenderWidget::RequestOutputSurface() {
+  if (direct_rendering_deps_) {
+    direct_rendering_deps_->RequestOutputSurface();
+  }
+
+  // TODO(khushalsagar): Add support for delegated rendering.
+}
+
+}  // namespace client
+}  // namespace blimp