aw: Split hardware rendering into HardwareRenderer

android_webview/browser/browser_view_renderer.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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_view_renderer.h"
+#include "android_webview/browser/browser_view_renderer.h"
 
-#include "android_webview/browser/aw_gl_surface.h"
-#include "android_webview/browser/scoped_app_gl_state_restore.h"
-#include "android_webview/common/aw_switches.h"
+#include "android_webview/browser/hardware_renderer.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
-#include "base/command_line.h"
 #include "base/debug/trace_event.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/content_switches.h"
-#include "gpu/command_buffer/service/in_process_command_buffer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
-#include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using base::android::AttachCurrentThread;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 
 namespace android_webview {
 
 namespace {
 
-const void* kUserDataKey = &kUserDataKey;
-
-class UserData : public content::WebContents::Data {
- public:
-  UserData(InProcessViewRenderer* ptr) : instance_(ptr) {}
-  virtual ~UserData() {
-    instance_->WebContentsGone();
-  }
-
-  static InProcessViewRenderer* GetInstance(content::WebContents* contents) {
-    if (!contents)
-      return NULL;
-    UserData* data = reinterpret_cast<UserData*>(
-        contents->GetUserData(kUserDataKey));
-    return data ? data->instance_ : NULL;
-  }
-
- private:
-  InProcessViewRenderer* instance_;
-};
-
-bool HardwareEnabled() {
-  static bool g_hw_enabled = !CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableWebViewGLMode);
-  return g_hw_enabled;
-}
-
 const int64 kFallbackTickTimeoutInMilliseconds = 20;
 
-// Used to calculate memory and resource allocation. Determined experimentally.
-size_t g_memory_multiplier = 10;
-size_t g_num_gralloc_limit = 150;
-const size_t kBytesPerPixel = 4;
-const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
-
-base::LazyInstance<GLViewRendererManager>::Leaky g_view_renderer_manager =
-    LAZY_INSTANCE_INITIALIZER;
-
-class ScopedAllowGL {
- public:
-  ScopedAllowGL();
-  ~ScopedAllowGL();
-
-  static bool IsAllowed() {
-    return g_view_renderer_manager.Get().OnRenderThread() && allow_gl;
-  }
-
- private:
-  static bool allow_gl;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowGL);
-};
-
-ScopedAllowGL::ScopedAllowGL() {
-  DCHECK(g_view_renderer_manager.Get().OnRenderThread());
-  DCHECK(!allow_gl);
-  allow_gl = true;
-}
-
-ScopedAllowGL::~ScopedAllowGL() {
-  allow_gl = false;
-}
-
-bool ScopedAllowGL::allow_gl = false;
-
-void RequestProcessGLOnUIThread() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE, base::Bind(&RequestProcessGLOnUIThread));
-    return;
-  }
-
-  InProcessViewRenderer* renderer = static_cast<InProcessViewRenderer*>(
-      g_view_renderer_manager.Get().GetMostRecentlyDrawn());
-  if (!renderer || !renderer->RequestProcessGL()) {
-    LOG(ERROR) << "Failed to request GL process. Deadlock likely: "
-               << !!renderer;
-  }
-}
-
-class DeferredGpuCommandService
-    : public gpu::InProcessCommandBuffer::Service,
-      public base::RefCountedThreadSafe<DeferredGpuCommandService> {
- public:
-  DeferredGpuCommandService();
-
-  virtual void ScheduleTask(const base::Closure& task) OVERRIDE;
-  virtual void ScheduleIdleWork(const base::Closure& task) OVERRIDE;
-  virtual bool UseVirtualizedGLContexts() OVERRIDE;
-
-  void RunTasks();
-
-  virtual void AddRef() const OVERRIDE {
-    base::RefCountedThreadSafe<DeferredGpuCommandService>::AddRef();
-  }
-  virtual void Release() const OVERRIDE {
-    base::RefCountedThreadSafe<DeferredGpuCommandService>::Release();
-  }
-
- protected:
-  virtual ~DeferredGpuCommandService();
-  friend class base::RefCountedThreadSafe<DeferredGpuCommandService>;
-
- private:
-  base::Lock tasks_lock_;
-  std::queue<base::Closure> tasks_;
-  DISALLOW_COPY_AND_ASSIGN(DeferredGpuCommandService);
-};
-
-DeferredGpuCommandService::DeferredGpuCommandService() {}
-
-DeferredGpuCommandService::~DeferredGpuCommandService() {
-  base::AutoLock lock(tasks_lock_);
-  DCHECK(tasks_.empty());
-}
-
-// Called from different threads!
-void DeferredGpuCommandService::ScheduleTask(const base::Closure& task) {
-  {
-    base::AutoLock lock(tasks_lock_);
-    tasks_.push(task);
-  }
-  if (ScopedAllowGL::IsAllowed()) {
-    RunTasks();
-  } else {
-    RequestProcessGLOnUIThread();
-  }
-}
-
-void DeferredGpuCommandService::ScheduleIdleWork(
-    const base::Closure& callback) {
-  // TODO(sievers): Should this do anything?
-}
-
-bool DeferredGpuCommandService::UseVirtualizedGLContexts() { return true; }
-
-void DeferredGpuCommandService::RunTasks() {
-  bool has_more_tasks;
-  {
-    base::AutoLock lock(tasks_lock_);
-    has_more_tasks = tasks_.size() > 0;
-  }
-
-  while (has_more_tasks) {
-    base::Closure task;
-    {
-      base::AutoLock lock(tasks_lock_);
-      task = tasks_.front();
-      tasks_.pop();
-    }
-    task.Run();
-    {
-      base::AutoLock lock(tasks_lock_);
-      has_more_tasks = tasks_.size() > 0;
-    }
-
-  }
-}
-
-base::LazyInstance<scoped_refptr<DeferredGpuCommandService> > g_service =
-    LAZY_INSTANCE_INITIALIZER;
-
 }  // namespace
 
-InProcessViewRenderer::InProcessViewRenderer(
-    BrowserViewRenderer::Client* client,
-    content::WebContents* web_contents)
+BrowserViewRenderer::BrowserViewRenderer(BrowserViewRendererClient* client,
+                                         content::WebContents* web_contents)
     : client_(client),
       web_contents_(web_contents),
       compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
       compositor_needs_continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
-      height_(0),
-      hardware_initialized_(false),
-      hardware_failed_(false),
-      last_egl_context_(NULL),
-      manager_key_(g_view_renderer_manager.Get().NullKey()) {
+      height_(0) {
   CHECK(web_contents_);
-  web_contents_->SetUserData(kUserDataKey, new UserData(this));
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);
 
   // Currently the logic in this class relies on |compositor_| remaining NULL
   // until the DidInitializeCompositor() call, hence it is not set here.
 }
 
-InProcessViewRenderer::~InProcessViewRenderer() {
-  CHECK(web_contents_);
+BrowserViewRenderer::~BrowserViewRenderer() {
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL);
-  web_contents_->SetUserData(kUserDataKey, NULL);
-  NoLongerExpectsDrawGL();
-  DCHECK(web_contents_ == NULL);  // WebContentsGone should have been called.
 }
 
-void InProcessViewRenderer::NoLongerExpectsDrawGL() {
-  GLViewRendererManager& mru = g_view_renderer_manager.Get();
-  if (manager_key_ != mru.NullKey()) {
-    mru.NoLongerExpectsDrawGL(manager_key_);
-    manager_key_ = mru.NullKey();
+void BrowserViewRenderer::TrimMemory(int level) {
+  if (hardware_renderer_) {
+    client_->UpdateGlobalVisibleRect();
+    bool visible = view_visible_ && window_visible_ &&
+                   !cached_global_visible_rect_.IsEmpty();
+    if (hardware_renderer_->TrimMemory(level, visible)) {
+      // Force a draw for compositor to drop tiles synchronously.
+      ForceFakeCompositeSW();
+    }
   }
 }
 
-// static
-InProcessViewRenderer* InProcessViewRenderer::FromWebContents(
-    content::WebContents* contents) {
-  return UserData::GetInstance(contents);
-}
-
-void InProcessViewRenderer::WebContentsGone() {
-  web_contents_ = NULL;
-  compositor_ = NULL;
-}
-
-// static
-void InProcessViewRenderer::CalculateTileMemoryPolicy() {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (cl->HasSwitch(switches::kTileMemoryMultiplier)) {
-    std::string string_value =
-        cl->GetSwitchValueASCII(switches::kTileMemoryMultiplier);
-    int int_value = 0;
-    if (base::StringToInt(string_value, &int_value) &&
-        int_value >= 2 && int_value <= 50) {
-      g_memory_multiplier = int_value;
-    }
-  }
-
-  if (cl->HasSwitch(switches::kNumGrallocBuffersPerWebview)) {
-    std::string string_value =
-        cl->GetSwitchValueASCII(switches::kNumGrallocBuffersPerWebview);
-    int int_value = 0;
-    if (base::StringToInt(string_value, &int_value) &&
-        int_value >= 50 && int_value <= 500) {
-      g_num_gralloc_limit = int_value;
-    }
-  }
-
-  const char kDefaultTileSize[] = "384";
-  if (!cl->HasSwitch(switches::kDefaultTileWidth))
-    cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize);
-
-  if (!cl->HasSwitch(switches::kDefaultTileHeight))
-    cl->AppendSwitchASCII(switches::kDefaultTileHeight, kDefaultTileSize);
-}
-
-bool InProcessViewRenderer::RequestProcessGL() {
-  return client_->RequestDrawGL(NULL);
-}
-
-void InProcessViewRenderer::TrimMemory(int level) {
-  // Constants from Android ComponentCallbacks2.
-  enum {
-    TRIM_MEMORY_RUNNING_LOW = 10,
-    TRIM_MEMORY_UI_HIDDEN = 20,
-    TRIM_MEMORY_BACKGROUND = 40,
-  };
-
-  // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because
-  // it does not indicate memory pressure, but merely that the app is
-  // backgrounded.
-  if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
-    return;
-
-  // Nothing to drop.
-  if (!attached_to_window_ || !hardware_initialized_ || !compositor_)
-    return;
-
-  // Do not release resources on view we expect to get DrawGL soon.
-  if (level < TRIM_MEMORY_BACKGROUND) {
-    client_->UpdateGlobalVisibleRect();
-    if (view_visible_ && window_visible_ &&
-        !cached_global_visible_rect_.IsEmpty()) {
-      return;
-    }
-  }
-
-  if (!eglGetCurrentContext()) {
-    NOTREACHED();
-    return;
-  }
-
-  // Just set the memory limit to 0 and drop all tiles. This will be reset to
-  // normal levels in the next DrawGL call.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = 0;
-  policy.num_resources_limit = 0;
-  if (memory_policy_ == policy)
-    return;
-
-  TRACE_EVENT0("android_webview", "InProcessViewRenderer::TrimMemory");
-  ScopedAppGLStateRestore state_restore(
-      ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
-  g_service.Get()->RunTasks();
-  ScopedAllowGL allow_gl;
-
-  SetMemoryPolicy(policy);
-  ForceFakeCompositeSW();
-}
-
-void InProcessViewRenderer::SetMemoryPolicy(
-    content::SynchronousCompositorMemoryPolicy& new_policy) {
-  if (memory_policy_ == new_policy)
-    return;
-
-  memory_policy_ = new_policy;
-  compositor_->SetMemoryPolicy(memory_policy_);
-}
-
-void InProcessViewRenderer::UpdateCachedGlobalVisibleRect() {
-  client_->UpdateGlobalVisibleRect();
-}
-
-bool InProcessViewRenderer::OnDraw(jobject java_canvas,
-                                   bool is_hardware_canvas,
-                                   const gfx::Vector2d& scroll,
-                                   const gfx::Rect& clip) {
-  scroll_at_start_of_frame_  = scroll;
+bool BrowserViewRenderer::OnDraw(jobject java_canvas,
+                                 bool is_hardware_canvas,
+                                 const gfx::Vector2d& scroll,
+                                 const gfx::Rect& clip) {
+  scroll_at_start_of_frame_ = scroll;
   if (clear_view_)
     return false;
-  if (is_hardware_canvas && attached_to_window_ && HardwareEnabled()) {
+  if (is_hardware_canvas && attached_to_window_) {
     // We should be performing a hardware draw here. If we don't have the
-    // comositor yet or if RequestDrawGL fails, it means we failed this draw and
-    // thus return false here to clear to background color for this draw.
+    // compositor yet or if RequestDrawGL fails, it means we failed this draw
+    // and thus return false here to clear to background color for this draw.
     return compositor_ && client_->RequestDrawGL(java_canvas);
   }
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
-bool InProcessViewRenderer::InitializeHwDraw() {
-  TRACE_EVENT0("android_webview", "InitializeHwDraw");
-  DCHECK(!gl_surface_);
-  gl_surface_ = new AwGLSurface;
-  if (!g_service.Get()) {
-    g_service.Get() = new DeferredGpuCommandService;
-    content::SynchronousCompositor::SetGpuService(g_service.Get());
+void BrowserViewRenderer::DrawGL(AwDrawGLInfo* draw_info) {
+  if (!attached_to_window_ || !compositor_)
+    return;
+
+  client_->UpdateGlobalVisibleRect();
+  if (cached_global_visible_rect_.IsEmpty())
+    return;
+
+  if (!hardware_renderer_)
+    hardware_renderer_.reset(new HardwareRenderer(compositor_, client_));
+
+  DrawGLInput input;
+  input.global_visible_rect = cached_global_visible_rect_;
+  input.scroll = scroll_at_start_of_frame_;
+  DrawGLResult result;
+  {
+    base::AutoReset<bool> auto_reset(&block_invalidates_, true);
+    result = hardware_renderer_->DrawGL(draw_info, input);
   }
-  hardware_failed_ = !compositor_->InitializeHwDraw(gl_surface_);
-  hardware_initialized_ = true;
 
-  if (hardware_failed_)
-    gl_surface_ = NULL;
-
-  return !hardware_failed_;
+  if (result.did_draw) {
+    fallback_tick_.Cancel();
+    block_invalidates_ = false;
+    EnsureContinuousInvalidation(draw_info, !result.clip_contains_visible_rect);
+  }
 }
 
-void InProcessViewRenderer::DrawGL(AwDrawGLInfo* draw_info) {
-  TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawGL");
-
-  manager_key_ = g_view_renderer_manager.Get().DidDrawGL(manager_key_, this);
-
-  // We need to watch if the current Android context has changed and enforce
-  // a clean-up in the compositor.
-  EGLContext current_context = eglGetCurrentContext();
-  if (!current_context) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_NullEGLContext", TRACE_EVENT_SCOPE_THREAD);
-    return;
-  }
-
-  ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW);
-  if (g_service.Get())
-    g_service.Get()->RunTasks();
-  ScopedAllowGL allow_gl;
-
-  if (!attached_to_window_) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_NotAttached", TRACE_EVENT_SCOPE_THREAD);
-    return;
-  }
-
-  if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_ModeProcess", TRACE_EVENT_SCOPE_THREAD);
-    return;
-  }
-
-  if (compositor_ && !hardware_initialized_) {
-    if (InitializeHwDraw()) {
-      last_egl_context_ = current_context;
-    } else {
-      TRACE_EVENT_INSTANT0(
-          "android_webview", "EarlyOut_HwInitFail", TRACE_EVENT_SCOPE_THREAD);
-      LOG(ERROR) << "WebView hardware initialization failed";
-      return;
-    }
-  }
-
-  UpdateCachedGlobalVisibleRect();
-  if (cached_global_visible_rect_.IsEmpty()) {
-    TRACE_EVENT_INSTANT0("android_webview",
-                         "EarlyOut_EmptyVisibleRect",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return;
-  }
-
-  if (last_egl_context_ != current_context) {
-    // TODO(boliu): Handle context lost
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EGLContextChanged", TRACE_EVENT_SCOPE_THREAD);
-  }
-
-  if (!compositor_) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
-    return;
-  }
-
-  // DrawGL may be called without OnDraw, so cancel |fallback_tick_| here as
-  // well just to be safe.
-  fallback_tick_.Cancel();
-
-  // Update memory budget. This will no-op in compositor if the policy has not
-  // changed since last draw.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = g_memory_multiplier * kBytesPerPixel *
-                       cached_global_visible_rect_.width() *
-                       cached_global_visible_rect_.height();
-  // Round up to a multiple of kMemoryAllocationStep.
-  policy.bytes_limit =
-      (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
-  policy.num_resources_limit = g_num_gralloc_limit;
-  SetMemoryPolicy(policy);
-
-  DCHECK(gl_surface_);
-  gl_surface_->SetBackingFrameBufferObject(
-      state_restore.framebuffer_binding_ext());
-
-  gfx::Transform transform;
-  transform.matrix().setColMajorf(draw_info->transform);
-  transform.Translate(scroll_at_start_of_frame_.x(),
-                      scroll_at_start_of_frame_.y());
-  gfx::Rect clip_rect(draw_info->clip_left,
-                      draw_info->clip_top,
-                      draw_info->clip_right - draw_info->clip_left,
-                      draw_info->clip_bottom - draw_info->clip_top);
-
-  // Assume we always draw the full visible rect if we are drawing into a layer.
-  bool drew_full_visible_rect = true;
-
-  gfx::Rect viewport_rect;
-  if (!draw_info->is_layer) {
-    viewport_rect = cached_global_visible_rect_;
-    clip_rect.Intersect(viewport_rect);
-    drew_full_visible_rect = clip_rect.Contains(viewport_rect);
-  } else {
-    viewport_rect = clip_rect;
-  }
-
-  block_invalidates_ = true;
-  // TODO(joth): Check return value.
-  compositor_->DemandDrawHw(gfx::Size(draw_info->width, draw_info->height),
-                            transform,
-                            viewport_rect,
-                            clip_rect,
-                            state_restore.stencil_enabled());
-  block_invalidates_ = false;
-  gl_surface_->ResetBackingFrameBufferObject();
-
-  EnsureContinuousInvalidation(draw_info, !drew_full_visible_rect);
-}
-
-void InProcessViewRenderer::SetGlobalVisibleRect(
-    const gfx::Rect& visible_rect) {
+void BrowserViewRenderer::SetGlobalVisibleRect(const gfx::Rect& visible_rect) {
   cached_global_visible_rect_ = visible_rect;
 }
 
-bool InProcessViewRenderer::DrawSWInternal(jobject java_canvas,
-                                           const gfx::Rect& clip) {
+bool BrowserViewRenderer::DrawSWInternal(jobject java_canvas,
+                                         const gfx::Rect& clip) {
   if (clip.IsEmpty()) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  return JavaHelper::GetInstance()->RenderViaAuxilaryBitmapIfNeeded(
-      java_canvas,
-      scroll_at_start_of_frame_,
-      clip,
-      base::Bind(&InProcessViewRenderer::CompositeSW, base::Unretained(this)));
+  return BrowserViewRendererJavaHelper::GetInstance()
+      ->RenderViaAuxilaryBitmapIfNeeded(
+            java_canvas,
+            scroll_at_start_of_frame_,
+            clip,
+            base::Bind(&BrowserViewRenderer::CompositeSW,
+                       base::Unretained(this)));
 }
 
-skia::RefPtr<SkPicture> InProcessViewRenderer::CapturePicture(int width,
-                                                              int height) {
-  TRACE_EVENT0("android_webview", "InProcessViewRenderer::CapturePicture");
+skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
+                                                            int height) {
+  TRACE_EVENT0("android_webview", "BrowserViewRenderer::CapturePicture");
 
   // Return empty Picture objects for empty SkPictures.
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture);
   if (width <= 0 || height <= 0) {
     return picture;
   }
 
   // Reset scroll back to the origin, will go back to the old
   // value when scroll_reset is out of scope.
   base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_dip_,
                                                gfx::Vector2d());
 
   SkCanvas* rec_canvas = picture->beginRecording(width, height, 0);
   if (compositor_)
     CompositeSW(rec_canvas);
   picture->endRecording();
   return picture;
 }
 
-void InProcessViewRenderer::EnableOnNewPicture(bool enabled) {
+void BrowserViewRenderer::EnableOnNewPicture(bool enabled) {
   on_new_picture_enable_ = enabled;
   EnsureContinuousInvalidation(NULL, false);
 }
 
-void InProcessViewRenderer::ClearView() {
+void BrowserViewRenderer::ClearView() {
   TRACE_EVENT_INSTANT0("android_webview",
-                       "InProcessViewRenderer::ClearView",
+                       "BrowserViewRenderer::ClearView",
                        TRACE_EVENT_SCOPE_THREAD);
   if (clear_view_)
     return;
 
   clear_view_ = true;
   // Always invalidate ignoring the compositor to actually clear the webview.
   EnsureContinuousInvalidation(NULL, true);
 }
 
-void InProcessViewRenderer::SetIsPaused(bool paused) {
+void BrowserViewRenderer::SetIsPaused(bool paused) {
   TRACE_EVENT_INSTANT1("android_webview",
-                       "InProcessViewRenderer::SetIsPaused",
+                       "BrowserViewRenderer::SetIsPaused",
                        TRACE_EVENT_SCOPE_THREAD,
                        "paused",
                        paused);
   is_paused_ = paused;
   EnsureContinuousInvalidation(NULL, false);
 }
 
-void InProcessViewRenderer::SetViewVisibility(bool view_visible) {
+void BrowserViewRenderer::SetViewVisibility(bool view_visible) {
   TRACE_EVENT_INSTANT1("android_webview",
-                       "InProcessViewRenderer::SetViewVisibility",
+                       "BrowserViewRenderer::SetViewVisibility",
                        TRACE_EVENT_SCOPE_THREAD,
                        "view_visible",
                        view_visible);
   view_visible_ = view_visible;
 }
 
-void InProcessViewRenderer::SetWindowVisibility(bool window_visible) {
+void BrowserViewRenderer::SetWindowVisibility(bool window_visible) {
   TRACE_EVENT_INSTANT1("android_webview",
-                       "InProcessViewRenderer::SetWindowVisibility",
+                       "BrowserViewRenderer::SetWindowVisibility",
                        TRACE_EVENT_SCOPE_THREAD,
                        "window_visible",
                        window_visible);
   window_visible_ = window_visible;
   EnsureContinuousInvalidation(NULL, false);
 }
 
-void InProcessViewRenderer::OnSizeChanged(int width, int height) {
+void BrowserViewRenderer::OnSizeChanged(int width, int height) {
   TRACE_EVENT_INSTANT2("android_webview",
-                       "InProcessViewRenderer::OnSizeChanged",
+                       "BrowserViewRenderer::OnSizeChanged",
                        TRACE_EVENT_SCOPE_THREAD,
                        "width",
                        width,
                        "height",
                        height);
   width_ = width;
   height_ = height;
 }
 
-void InProcessViewRenderer::OnAttachedToWindow(int width, int height) {
+void BrowserViewRenderer::OnAttachedToWindow(int width, int height) {
   TRACE_EVENT2("android_webview",
-               "InProcessViewRenderer::OnAttachedToWindow",
+               "BrowserViewRenderer::OnAttachedToWindow",
                "width",
                width,
                "height",
                height);
   attached_to_window_ = true;
   width_ = width;
   height_ = height;
 }
 
-void InProcessViewRenderer::OnDetachedFromWindow() {
-  TRACE_EVENT0("android_webview",
-               "InProcessViewRenderer::OnDetachedFromWindow");
-
-  NoLongerExpectsDrawGL();
-  if (hardware_initialized_) {
-    DCHECK(compositor_);
-
-    ScopedAppGLStateRestore state_restore(
-        ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
-    g_service.Get()->RunTasks();
-    ScopedAllowGL allow_gl;
-    compositor_->ReleaseHwDraw();
-    hardware_initialized_ = false;
-  }
-
-  gl_surface_ = NULL;
+void BrowserViewRenderer::OnDetachedFromWindow() {
+  TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   attached_to_window_ = false;
+  hardware_renderer_.reset();
 }
 
-bool InProcessViewRenderer::IsAttachedToWindow() {
+bool BrowserViewRenderer::IsAttachedToWindow() const {
   return attached_to_window_;
 }
 
-bool InProcessViewRenderer::IsVisible() {
+bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
 }
 
-gfx::Rect InProcessViewRenderer::GetScreenRect() {
+gfx::Rect BrowserViewRenderer::GetScreenRect() const {
   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
 }
 
-void InProcessViewRenderer::DidInitializeCompositor(
+void BrowserViewRenderer::DidInitializeCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview",
-               "InProcessViewRenderer::DidInitializeCompositor");
+               "BrowserViewRenderer::DidInitializeCompositor");
   DCHECK(compositor && compositor_ == NULL);
   compositor_ = compositor;
-  hardware_initialized_ = false;
-  hardware_failed_ = false;
 }
 
-void InProcessViewRenderer::DidDestroyCompositor(
+void BrowserViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
-  TRACE_EVENT0("android_webview",
-               "InProcessViewRenderer::DidDestroyCompositor");
+  TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
   DCHECK(compositor_ == compositor);
-
-  // This can fail if Apps call destroy while the webview is still attached
-  // to the view tree. This is an illegal operation that will lead to leaks.
-  // Log for now. Consider a proper fix if this becomes a problem.
-  LOG_IF(ERROR, hardware_initialized_)
-      << "Destroy called before OnDetachedFromWindow. May Leak GL resources";
+  DCHECK(!hardware_renderer_.get());
   compositor_ = NULL;
 }
 
-void InProcessViewRenderer::SetContinuousInvalidate(bool invalidate) {
+void BrowserViewRenderer::SetContinuousInvalidate(bool invalidate) {
   if (compositor_needs_continuous_invalidate_ == invalidate)
     return;
 
   TRACE_EVENT_INSTANT1("android_webview",
-                       "InProcessViewRenderer::SetContinuousInvalidate",
+                       "BrowserViewRenderer::SetContinuousInvalidate",
                        TRACE_EVENT_SCOPE_THREAD,
                        "invalidate",
                        invalidate);
   compositor_needs_continuous_invalidate_ = invalidate;
   EnsureContinuousInvalidation(NULL, false);
 }
 
-void InProcessViewRenderer::SetDipScale(float dip_scale) {
+void BrowserViewRenderer::SetDipScale(float dip_scale) {
   dip_scale_ = dip_scale;
   CHECK(dip_scale_ > 0);
 }
 
-gfx::Vector2d InProcessViewRenderer::max_scroll_offset() const {
+gfx::Vector2d BrowserViewRenderer::max_scroll_offset() const {
   DCHECK_GT(dip_scale_, 0);
   return gfx::ToCeiledVector2d(gfx::ScaleVector2d(
       max_scroll_offset_dip_, dip_scale_ * page_scale_factor_));
 }
 
-void InProcessViewRenderer::ScrollTo(gfx::Vector2d scroll_offset) {
+void BrowserViewRenderer::ScrollTo(gfx::Vector2d scroll_offset) {
   gfx::Vector2d max_offset = max_scroll_offset();
   gfx::Vector2dF scroll_offset_dip;
   // To preserve the invariant that scrolling to the maximum physical pixel
   // value also scrolls to the maximum dip pixel value we transform the physical
   // offset into the dip offset by using a proportion (instead of dividing by
   // dip_scale * page_scale_factor).
   if (max_offset.x()) {
     scroll_offset_dip.set_x((scroll_offset.x() * max_scroll_offset_dip_.x()) /
                             max_offset.x());
   }
   if (max_offset.y()) {
     scroll_offset_dip.set_y((scroll_offset.y() * max_scroll_offset_dip_.y()) /
                             max_offset.y());
   }
 
   DCHECK_LE(0, scroll_offset_dip.x());
   DCHECK_LE(0, scroll_offset_dip.y());
   DCHECK_LE(scroll_offset_dip.x(), max_scroll_offset_dip_.x());
   DCHECK_LE(scroll_offset_dip.y(), max_scroll_offset_dip_.y());
 
   if (scroll_offset_dip_ == scroll_offset_dip)
     return;
 
   scroll_offset_dip_ = scroll_offset_dip;
 
   if (compositor_)
     compositor_->DidChangeRootLayerScrollOffset();
 }
 
-void InProcessViewRenderer::DidUpdateContent() {
+void BrowserViewRenderer::DidUpdateContent() {
   TRACE_EVENT_INSTANT0("android_webview",
-                       "InProcessViewRenderer::DidUpdateContent",
+                       "BrowserViewRenderer::DidUpdateContent",
                        TRACE_EVENT_SCOPE_THREAD);
   clear_view_ = false;
   EnsureContinuousInvalidation(NULL, false);
   if (on_new_picture_enable_)
     client_->OnNewPicture();
 }
 
-void InProcessViewRenderer::SetMaxRootLayerScrollOffset(
+void BrowserViewRenderer::SetMaxRootLayerScrollOffset(
     gfx::Vector2dF new_value_dip) {
   DCHECK_GT(dip_scale_, 0);
 
   max_scroll_offset_dip_ = new_value_dip;
   DCHECK_LE(0, max_scroll_offset_dip_.x());
   DCHECK_LE(0, max_scroll_offset_dip_.y());
 
   client_->SetMaxContainerViewScrollOffset(max_scroll_offset());
 }
 
-void InProcessViewRenderer::SetTotalRootLayerScrollOffset(
+void BrowserViewRenderer::SetTotalRootLayerScrollOffset(
     gfx::Vector2dF scroll_offset_dip) {
   // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
   // DrawGl when http://crbug.com/249972 is fixed.
   if (scroll_offset_dip_ == scroll_offset_dip)
     return;
 
   scroll_offset_dip_ = scroll_offset_dip;
 
   gfx::Vector2d max_offset = max_scroll_offset();
   gfx::Vector2d scroll_offset;
   // For an explanation as to why this is done this way see the comment in
-  // InProcessViewRenderer::ScrollTo.
+  // BrowserViewRenderer::ScrollTo.
   if (max_scroll_offset_dip_.x()) {
     scroll_offset.set_x((scroll_offset_dip.x() * max_offset.x()) /
                         max_scroll_offset_dip_.x());
   }
 
   if (max_scroll_offset_dip_.y()) {
     scroll_offset.set_y((scroll_offset_dip.y() * max_offset.y()) /
                         max_scroll_offset_dip_.y());
   }
 
   DCHECK(0 <= scroll_offset.x());
   DCHECK(0 <= scroll_offset.y());
   // Disabled because the conditions are being violated while running
   // AwZoomTest.testMagnification, see http://crbug.com/340648
   // DCHECK(scroll_offset.x() <= max_offset.x());
   // DCHECK(scroll_offset.y() <= max_offset.y());
 
   client_->ScrollContainerViewTo(scroll_offset);
 }
 
-gfx::Vector2dF InProcessViewRenderer::GetTotalRootLayerScrollOffset() {
+gfx::Vector2dF BrowserViewRenderer::GetTotalRootLayerScrollOffset() {
   return scroll_offset_dip_;
 }
 
-bool InProcessViewRenderer::IsExternalFlingActive() const {
+bool BrowserViewRenderer::IsExternalFlingActive() const {
   return client_->IsFlingActive();
 }
 
-void InProcessViewRenderer::SetRootLayerPageScaleFactorAndLimits(
+void BrowserViewRenderer::SetRootLayerPageScaleFactorAndLimits(
     float page_scale_factor,
     float min_page_scale_factor,
     float max_page_scale_factor) {
   page_scale_factor_ = page_scale_factor;
   DCHECK_GT(page_scale_factor_, 0);
   client_->SetPageScaleFactorAndLimits(
       page_scale_factor, min_page_scale_factor, max_page_scale_factor);
 }
 
-void InProcessViewRenderer::SetRootLayerScrollableSize(
+void BrowserViewRenderer::SetRootLayerScrollableSize(
     gfx::SizeF scrollable_size) {
   client_->SetContentsSize(scrollable_size);
 }
 
-void InProcessViewRenderer::DidOverscroll(
-    gfx::Vector2dF accumulated_overscroll,
-    gfx::Vector2dF latest_overscroll_delta,
-    gfx::Vector2dF current_fling_velocity) {
+void BrowserViewRenderer::DidOverscroll(gfx::Vector2dF accumulated_overscroll,
+                                        gfx::Vector2dF latest_overscroll_delta,
+                                        gfx::Vector2dF current_fling_velocity) {
   const float physical_pixel_scale = dip_scale_ * page_scale_factor_;
   if (accumulated_overscroll == latest_overscroll_delta)
     overscroll_rounding_error_ = gfx::Vector2dF();
   gfx::Vector2dF scaled_overscroll_delta =
       gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale);
   gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d(
       scaled_overscroll_delta + overscroll_rounding_error_);
   overscroll_rounding_error_ =
       scaled_overscroll_delta - rounded_overscroll_delta;
   client_->DidOverscroll(rounded_overscroll_delta);
 }
 
-void InProcessViewRenderer::EnsureContinuousInvalidation(
+void BrowserViewRenderer::EnsureContinuousInvalidation(
     AwDrawGLInfo* draw_info,
     bool invalidate_ignore_compositor) {
   // This method should be called again when any of these conditions change.
   bool need_invalidate =
       compositor_needs_continuous_invalidate_ || invalidate_ignore_compositor;
   if (!need_invalidate || block_invalidates_)
     return;
 
   // Always call view invalidate. We rely the Android framework to ignore the
   // invalidate when it's not needed such as when view is not visible.
@@ skipping 15 matching lines @@
   // "on-screen" but that updates are not needed when in the background.
   bool throttle_fallback_tick =
       (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);
   if (throttle_fallback_tick)
     return;
 
   block_invalidates_ = compositor_needs_continuous_invalidate_;
 
   // Unretained here is safe because the callback is cancelled when
   // |fallback_tick_| is destroyed.
-  fallback_tick_.Reset(base::Bind(&InProcessViewRenderer::FallbackTickFired,
+  fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::FallbackTickFired,
                                   base::Unretained(this)));
 
   // No need to reschedule fallback tick if compositor does not need to be
   // ticked. This can happen if this is reached because
   // invalidate_ignore_compositor is true.
   if (compositor_needs_continuous_invalidate_) {
     BrowserThread::PostDelayedTask(
         BrowserThread::UI,
         FROM_HERE,
         fallback_tick_.callback(),
-        base::TimeDelta::FromMilliseconds(
-            kFallbackTickTimeoutInMilliseconds));
+        base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
   }
 }
 
-void InProcessViewRenderer::FallbackTickFired() {
+void BrowserViewRenderer::FallbackTickFired() {
   TRACE_EVENT1("android_webview",
-               "InProcessViewRenderer::FallbackTickFired",
+               "BrowserViewRenderer::FallbackTickFired",
                "compositor_needs_continuous_invalidate_",
                compositor_needs_continuous_invalidate_);
 
   // This should only be called if OnDraw or DrawGL did not come in time, which
   // means block_invalidates_ must still be true.
   DCHECK(block_invalidates_);
   if (compositor_needs_continuous_invalidate_ && compositor_)
     ForceFakeCompositeSW();
 }
 
-void InProcessViewRenderer::ForceFakeCompositeSW() {
+void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
   SkBitmapDevice device(SkBitmap::kARGB_8888_Config, 1, 1);
   SkCanvas canvas(&device);
   CompositeSW(&canvas);
 }
 
-bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
+bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(compositor_);
 
   fallback_tick_.Cancel();
   block_invalidates_ = true;
   bool result = compositor_->DemandDrawSw(canvas);
   block_invalidates_ = false;
   EnsureContinuousInvalidation(NULL, false);
   return result;
 }
 
-std::string InProcessViewRenderer::ToString(AwDrawGLInfo* draw_info) const {
+std::string BrowserViewRenderer::ToString(AwDrawGLInfo* draw_info) const {
   std::string str;
   base::StringAppendF(&str, "is_paused: %d ", is_paused_);
   base::StringAppendF(&str, "view_visible: %d ", view_visible_);
   base::StringAppendF(&str, "window_visible: %d ", window_visible_);
   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
   base::StringAppendF(&str,
                       "compositor_needs_continuous_invalidate: %d ",
                       compositor_needs_continuous_invalidate_);
   base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_);
   base::StringAppendF(&str, "view width height: [%d %d] ", width_, height_);
   base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_);
-  base::StringAppendF(&str, "hardware_initialized: %d ", hardware_initialized_);
-  base::StringAppendF(&str, "hardware_failed: %d ", hardware_failed_);
   base::StringAppendF(&str,
                       "global visible rect: %s ",
                       cached_global_visible_rect_.ToString().c_str());
   base::StringAppendF(&str,
                       "scroll_at_start_of_frame: %s ",
                       scroll_at_start_of_frame_.ToString().c_str());
   base::StringAppendF(
       &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str());
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
@@ skipping 11 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview