aw: Split hardware rendering into HardwareRenderer

android_webview/native/aw_contents.cc

 // Copyright 2012 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/native/aw_contents.h"
 
 #include <limits>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_browser_main_parts.h"
 #include "android_webview/browser/aw_resource_context.h"
+#include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/gpu_memory_buffer_factory_impl.h"
-#include "android_webview/browser/in_process_view_renderer.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
 #include "android_webview/common/aw_hit_test_data.h"
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_autofill_manager_delegate.h"
 #include "android_webview/native/aw_browser_dependency_factory.h"
 #include "android_webview/native/aw_contents_client_bridge.h"
 #include "android_webview/native/aw_contents_io_thread_client_impl.h"
 #include "android_webview/native/aw_pdf_exporter.h"
 #include "android_webview/native/aw_picture.h"
@@ skipping 154 matching lines @@
       content::RenderViewHost::FromID(render_process_id, render_view_id);
   if (!rvh) return NULL;
   content::WebContents* web_contents =
       content::WebContents::FromRenderViewHost(rvh);
   if (!web_contents) return NULL;
   return FromWebContents(web_contents);
 }
 
 AwContents::AwContents(scoped_ptr<WebContents> web_contents)
     : web_contents_(web_contents.Pass()),
-      browser_view_renderer_(new InProcessViewRenderer(
-          this,
-          web_contents_.get())) {
+      browser_view_renderer_(this, web_contents_.get()) {
   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
   icon_helper_.reset(new IconHelper(web_contents_.get()));
   icon_helper_->SetListener(this);
   web_contents_->SetUserData(kAwContentsUserDataKey,
                              new AwContentsUserData(this));
   render_view_host_ext_.reset(
       new AwRenderViewHostExt(this, web_contents_.get()));
 
   AwAutofillManagerDelegate* autofill_manager_delegate =
       AwAutofillManagerDelegate::FromWebContents(web_contents_.get());
@@ skipping 151 matching lines @@
   return reinterpret_cast<jint>(&DrawGLFunction);
 }
 
 // static
 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
   return base::subtle::NoBarrier_Load(&g_instance_count);
 }
 
 jint AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return reinterpret_cast<jint>(browser_view_renderer_.get());
+  return reinterpret_cast<jint>(&browser_view_renderer_);
 }
 
 namespace {
 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
                                bool has_images) {
   Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
                                               has_images,
                                               message.obj());
 }
 }  // namespace
@@ skipping 28 matching lines @@
       target_path,
       base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback), target_path));
 }
 
 void AwContents::CreatePdfExporter(JNIEnv* env,
                                    jobject obj,
                                    jobject pdfExporter) {
   pdf_exporter_.reset(
       new AwPdfExporter(env,
                         pdfExporter,
-                        browser_view_renderer_.get(),
                         web_contents_.get()));
 }
 
 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
                                            const std::string& host,
                                            const std::string& realm) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
@@ skipping 304 matching lines @@
                                     data.type,
                                     extra_data_for_type.obj(),
                                     href.obj(),
                                     anchor_text.obj(),
                                     img_src.obj());
 }
 
 void AwContents::OnSizeChanged(JNIEnv* env, jobject obj,
                                int w, int h, int ow, int oh) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->OnSizeChanged(w, h);
+  browser_view_renderer_.OnSizeChanged(w, h);
 }
 
 void AwContents::SetViewVisibility(JNIEnv* env, jobject obj, bool visible) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->SetViewVisibility(visible);
+  browser_view_renderer_.SetViewVisibility(visible);
 }
 
 void AwContents::SetWindowVisibility(JNIEnv* env, jobject obj, bool visible) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->SetWindowVisibility(visible);
+  browser_view_renderer_.SetWindowVisibility(visible);
 }
 
 void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->SetIsPaused(paused);
+  browser_view_renderer_.SetIsPaused(paused);
   ContentViewCore* cvc =
       ContentViewCore::FromWebContents(web_contents_.get());
   if (cvc) {
     cvc->PauseOrResumeGeolocation(paused);
     if (paused) {
       cvc->PauseVideo();
     }
   }
 }
 
 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->OnAttachedToWindow(w, h);
+  browser_view_renderer_.OnAttachedToWindow(w, h);
 }
 
 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->OnDetachedFromWindow();
+  browser_view_renderer_.OnDetachedFromWindow();
 }
 
 base::android::ScopedJavaLocalRef<jbyteArray>
 AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Required optimization in WebViewClassic to not save any state if
   // there has been no navigations.
   if (!web_contents_->GetController().GetEntryCount())
     return ScopedJavaLocalRef<jbyteArray>();
 
@@ skipping 25 matching lines @@
                         jobject obj,
                         jobject canvas,
                         jboolean is_hardware_accelerated,
                         jint scroll_x,
                         jint scroll_y,
                         jint clip_left,
                         jint clip_top,
                         jint clip_right,
                         jint clip_bottom) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return browser_view_renderer_->OnDraw(
+  return browser_view_renderer_.OnDraw(
       canvas,
       is_hardware_accelerated,
       gfx::Vector2d(scroll_x, scroll_y),
       gfx::Rect(
           clip_left, clip_top, clip_right - clip_left, clip_bottom - clip_top));
 }
 
 void AwContents::SetGlobalVisibleRect(JNIEnv* env,
                                       jobject obj,
                                       jint visible_left,
                                       jint visible_top,
                                       jint visible_right,
                                       jint visible_bottom) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->SetGlobalVisibleRect(
+  browser_view_renderer_.SetGlobalVisibleRect(
       gfx::Rect(visible_left,
                 visible_top,
                 visible_right - visible_left,
                 visible_bottom - visible_top));
 }
 
 void AwContents::SetPendingWebContentsForPopup(
     scoped_ptr<content::WebContents> pending) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (pending_contents_.get()) {
@@ skipping 93 matching lines @@
 void AwContents::DidOverscroll(gfx::Vector2d overscroll_delta) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_didOverscroll(
       env, obj.obj(), overscroll_delta.x(), overscroll_delta.y());
 }
 
+const BrowserViewRenderer* AwContents::GetBrowserViewRenderer() const {
+  return &browser_view_renderer_;
+}
+
 void AwContents::SetDipScale(JNIEnv* env, jobject obj, jfloat dip_scale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->SetDipScale(dip_scale);
+  browser_view_renderer_.SetDipScale(dip_scale);
 }
 
 void AwContents::SetFixedLayoutSize(JNIEnv* env,
                                     jobject obj,
                                     jint width_dip,
                                     jint height_dip) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   render_view_host_ext_->SetFixedLayoutSize(gfx::Size(width_dip, height_dip));
 }
 
 void AwContents::ScrollTo(JNIEnv* env, jobject obj, jint x, jint y) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->ScrollTo(gfx::Vector2d(x, y));
+  browser_view_renderer_.ScrollTo(gfx::Vector2d(x, y));
 }
 
 void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj.obj(),
                                                          page_scale_factor);
 }
 
 void AwContents::OnWebLayoutContentsSizeChanged(
     const gfx::Size& contents_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_onWebLayoutContentsSizeChanged(
       env, obj.obj(), contents_size.width(), contents_size.height());
 }
 
 jlong AwContents::CapturePicture(JNIEnv* env,
                                  jobject obj,
                                  int width,
                                  int height) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return reinterpret_cast<intptr_t>(new AwPicture(
-      browser_view_renderer_->CapturePicture(width, height)));
+  return reinterpret_cast<intptr_t>(
+      new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
 }
 
 void AwContents::EnableOnNewPicture(JNIEnv* env,
                                     jobject obj,
                                     jboolean enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->EnableOnNewPicture(enabled);
+  browser_view_renderer_.EnableOnNewPicture(enabled);
 }
 
 void AwContents::ClearView(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->ClearView();
+  browser_view_renderer_.ClearView();
 }
 
 void AwContents::SetExtraHeadersForUrl(JNIEnv* env, jobject obj,
                                        jstring url, jstring jextra_headers) {
   std::string extra_headers;
   if (jextra_headers)
     extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
   AwResourceContext* resource_context = static_cast<AwResourceContext*>(
       AwBrowserContext::FromWebContents(web_contents_.get())->
       GetResourceContext());
   resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
                                     extra_headers);
 }
 
 void AwContents::SetJsOnlineProperty(JNIEnv* env,
                                      jobject obj,
                                      jboolean network_up) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   render_view_host_ext_->SetJsOnlineProperty(network_up);
 }
 
 void AwContents::TrimMemory(JNIEnv* env, jobject obj, jint level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_->TrimMemory(level);
+  browser_view_renderer_.TrimMemory(level);
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview