Move synchronous compositor into content/browser

android_webview/browser/in_process_view_renderer.cc

 // Copyright (c) 2013 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 "android_webview/browser/in_process_renderer/in_process_view_renderer.h"
+#include "android_webview/browser/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/jni_android.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "content/public/browser/android/content_view_core.h"
+#include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/renderer/android/synchronous_compositor.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_f.h"
 #include "ui/gl/gl_bindings.h"
 
@@ skipping 243 matching lines @@
       width_(0),
       height_(0),
       attached_to_window_(false),
       hardware_initialized_(false),
       hardware_failed_(false),
       egl_context_at_init_(NULL),
       weak_factory_(this) {
 }
 
 InProcessViewRenderer::~InProcessViewRenderer() {
-  if (compositor_)
-    compositor_->SetClient(NULL);
   SetContents(NULL);
+  DCHECK(compositor_ == NULL);
 }
 
 // static
 InProcessViewRenderer* InProcessViewRenderer::FromWebContents(
     content::WebContents* contents) {
   return UserData::GetInstance(contents);
 }
 
-// static
-InProcessViewRenderer* InProcessViewRenderer::FromId(int render_process_id,
-                                                     int render_view_id) {
-  const content::RenderViewHost* rvh =
-      content::RenderViewHost::FromID(render_process_id, render_view_id);
-  if (!rvh) return NULL;
-  return InProcessViewRenderer::FromWebContents(
-      content::WebContents::FromRenderViewHost(rvh));
-}
-
-void InProcessViewRenderer::BindSynchronousCompositor(
-    content::SynchronousCompositor* compositor) {
-  DCHECK(compositor && compositor_ != compositor);
-  if (compositor_)
-    compositor_->SetClient(NULL);
-  compositor_ = compositor;
-  hardware_initialized_ = false;
-  hardware_failed_ = false;
-  compositor_->SetClient(this);
-
-  if (attached_to_window_)
-    client_->RequestProcessMode();
-}
-
 void InProcessViewRenderer::SetContents(
     content::ContentViewCore* content_view_core) {
   // First remove association from the prior ContentViewCore / WebContents.
+  if (compositor_)
+    compositor_->SetClient(NULL);
+  compositor_ = NULL;
   if (web_contents_) {
     web_contents_->SetUserData(kUserDataKey, NULL);
     DCHECK(!web_contents_);  // WebContentsGone should have been called.
   }
 
   if (!content_view_core)
     return;
 
   web_contents_ = content_view_core->GetWebContents();
   web_contents_->SetUserData(kUserDataKey, new UserData(this));
+  content::SynchronousCompositor::GetOrCreateForWebContents(web_contents_)->
+      SetClient(this);
+  // Currently the logic in this class relies on |compositor_| remaining NULL
+  // until the DidInitializeCompositor() call, hence it is not set here.
 }
 
 void InProcessViewRenderer::WebContentsGone() {
   web_contents_ = NULL;
 }
 
 bool InProcessViewRenderer::PrepareDrawGL(int x, int y) {
   // No harm in updating |hw_rendering_scroll_| even if we return false.
   hw_rendering_scroll_ = gfx::Point(x, y);
   return attached_to_window_ && compositor_ && compositor_->IsHwReady() &&
@@ skipping 203 matching lines @@
 }
 
 bool InProcessViewRenderer::IsViewVisible() {
   return view_visible_;
 }
 
 gfx::Rect InProcessViewRenderer::GetScreenRect() {
   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
 }
 
+void InProcessViewRenderer::DidInitializeCompositor(
+    content::SynchronousCompositor* compositor) {
+  DCHECK(compositor && compositor_ == NULL);
+  compositor_ = compositor;
+  hardware_initialized_ = false;
+  hardware_failed_ = false;
+
+  if (attached_to_window_)
+    client_->RequestProcessMode();
+}
+
 void InProcessViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
-  // Allow for transient hand-over when two compositors may reference
-  // a single client.
-  if (compositor_ == compositor)
-    compositor_ = NULL;
+  DCHECK(compositor_ == compositor);
+  compositor_ = NULL;
 }
 
 void InProcessViewRenderer::SetContinuousInvalidate(bool invalidate) {
   if (continuous_invalidate_ == invalidate)
     return;
 
   continuous_invalidate_ = invalidate;
   // TODO(boliu): Handle if not attached to window case.
   EnsureContinuousInvalidation();
 }
@@ skipping 17 matching lines @@
   // TODO(joth): BrowserViewRendererImpl had a bunch of logic for dpi and page
   // scale here. Determine what if any needs bringing over to this class.
   return CompositeSW(canvas);
 }
 
 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
   return compositor_ && compositor_->DemandDrawSw(canvas);
 }
 
 }  // namespace android_webview