android_webview/browser/shared_renderer_state.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/browser/shared_renderer_state.h"
   6
   7 #include "android_webview/browser/browser_view_renderer_client.h"
   8 #include "base/bind.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/location.h"
  11
  12 namespace android_webview {
  13
  14 namespace internal {
  15
  16 class RequestDrawGLTracker {
  17  public:
  18   RequestDrawGLTracker();
  19   bool ShouldRequestOnNoneUiThread(SharedRendererState* state);
  20   bool ShouldRequestOnUiThread(SharedRendererState* state);
  21   void DidRequestOnUiThread();
  22   void ResetPending();
  23
  24  private:
  25   base::Lock lock_;
  26   SharedRendererState* pending_ui_;
  27   SharedRendererState* pending_non_ui_;
  28 };
  29
  30 RequestDrawGLTracker::RequestDrawGLTracker()
  31     : pending_ui_(NULL), pending_non_ui_(NULL) {
  32 }
  33
  34 bool RequestDrawGLTracker::ShouldRequestOnNoneUiThread(
  35     SharedRendererState* state) {
  36   base::AutoLock lock(lock_);
  37   if (pending_ui_ || pending_non_ui_)
  38     return false;
  39   pending_non_ui_ = state;
  40   return true;
  41 }
  42
  43 bool RequestDrawGLTracker::ShouldRequestOnUiThread(SharedRendererState* state) {
  44   base::AutoLock lock(lock_);
  45   if (pending_non_ui_) {
  46     pending_non_ui_->ResetRequestDrawGLCallback();
  47     pending_non_ui_ = NULL;
  48   }
  49   if (pending_ui_)
  50     return false;
  51   pending_ui_ = state;
  52   return true;
  53 }
  54
  55 void RequestDrawGLTracker::ResetPending() {
  56   base::AutoLock lock(lock_);
  57   pending_non_ui_ = NULL;
  58   pending_ui_ = NULL;
  59 }
  60
  61 }  // namespace internal
  62
  63 namespace {
  64
  65 base::LazyInstance<internal::RequestDrawGLTracker> g_request_draw_gl_tracker =
  66     LAZY_INSTANCE_INITIALIZER;
  67
  68 }
  69
  70 DrawGLInput::DrawGLInput() : width(0), height(0) {
  71 }
  72
  73 DrawGLInput::~DrawGLInput() {
  74 }
  75
  76 SharedRendererState::SharedRendererState(
  77     scoped_refptr<base::MessageLoopProxy> ui_loop,
  78     BrowserViewRendererClient* client)
  79     : ui_loop_(ui_loop),
  80       client_on_ui_(client),
  81       inside_hardware_release_(false),
  82       weak_factory_on_ui_thread_(this){
  83   DCHECK(ui_loop_->BelongsToCurrentThread());
  84   DCHECK(client_on_ui_);
  85   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
  86   ResetRequestDrawGLCallback();
  87 }
  88
  89 SharedRendererState::~SharedRendererState() {
  90   DCHECK(ui_loop_->BelongsToCurrentThread());
  91 }
  92
  93 void SharedRendererState::ClientRequestDrawGL() {
  94   if (ui_loop_->BelongsToCurrentThread()) {
  95     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnUiThread(this))
  96       return;
  97     ClientRequestDrawGLOnUIThread();
  98   } else {
  99     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNoneUiThread(this))
 100       return;
 101     base::Closure callback;
 102     {
 103       base::AutoLock lock(lock_);
 104       callback = request_draw_gl_closure_;
 105     }
 106     ui_loop_->PostTask(FROM_HERE, callback);
 107   }
 108 }
 109
 110 void SharedRendererState::DidDrawGLProcess() {
 111   g_request_draw_gl_tracker.Get().ResetPending();
 112 }
 113
 114 void SharedRendererState::ResetRequestDrawGLCallback() {
 115   DCHECK(ui_loop_->BelongsToCurrentThread());
 116   base::AutoLock lock(lock_);
 117   request_draw_gl_cancelable_closure_.Reset(
 118       base::Bind(&SharedRendererState::ClientRequestDrawGLOnUIThread,
 119                  base::Unretained(this)));
 120   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 121 }
 122
 123 void SharedRendererState::ClientRequestDrawGLOnUIThread() {
 124   DCHECK(ui_loop_->BelongsToCurrentThread());
 125   ResetRequestDrawGLCallback();
 126   if (!client_on_ui_->RequestDrawGL(NULL, false)) {
 127     g_request_draw_gl_tracker.Get().ResetPending();
 128     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
 129   }
 130 }
 131
 132 void SharedRendererState::UpdateParentDrawConstraintsOnUIThread() {
 133   DCHECK(ui_loop_->BelongsToCurrentThread());
 134   client_on_ui_->UpdateParentDrawConstraints();
 135 }
 136
 137 void SharedRendererState::SetDrawGLInput(scoped_ptr<DrawGLInput> input) {
 138   base::AutoLock lock(lock_);
 139   DCHECK(!draw_gl_input_.get());
 140   draw_gl_input_ = input.Pass();
 141 }
 142
 143 scoped_ptr<DrawGLInput> SharedRendererState::PassDrawGLInput() {
 144   base::AutoLock lock(lock_);
 145   return draw_gl_input_.Pass();
 146 }
 147
 148 void SharedRendererState::UpdateDrawConstraints(
 149     const ParentCompositorDrawConstraints& parent_draw_constraints) {
 150   base::AutoLock lock(lock_);
 151   parent_draw_constraints_ = parent_draw_constraints;
 152 }
 153
 154 void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
 155     const ParentCompositorDrawConstraints& parent_draw_constraints) {
 156   UpdateDrawConstraints(parent_draw_constraints);
 157
 158   // No need to hold the lock_ during the post task.
 159   ui_loop_->PostTask(
 160       FROM_HERE,
 161       base::Bind(&SharedRendererState::UpdateParentDrawConstraintsOnUIThread,
 162                  ui_thread_weak_ptr_));
 163 }
 164
 165 const ParentCompositorDrawConstraints
 166 SharedRendererState::ParentDrawConstraints() const {
 167   base::AutoLock lock(lock_);
 168   return parent_draw_constraints_;
 169 }
 170
 171 void SharedRendererState::SetInsideHardwareRelease(bool inside) {
 172   base::AutoLock lock(lock_);
 173   inside_hardware_release_ = inside;
 174 }
 175
 176 bool SharedRendererState::IsInsideHardwareRelease() const {
 177   base::AutoLock lock(lock_);
 178   return inside_hardware_release_;
 179 }
 180
 181 void SharedRendererState::InsertReturnedResources(
 182     const cc::ReturnedResourceArray& resources) {
 183   base::AutoLock lock(lock_);
 184   returned_resources_.insert(
 185       returned_resources_.end(), resources.begin(), resources.end());
 186 }
 187
 188 void SharedRendererState::SwapReturnedResources(
 189     cc::ReturnedResourceArray* resources) {
 190   DCHECK(resources->empty());
 191   base::AutoLock lock(lock_);
 192   resources->swap(returned_resources_);
 193 }
 194
 195 bool SharedRendererState::ReturnedResourcesEmpty() const {
 196   base::AutoLock lock(lock_);
 197   return returned_resources_.empty();
 198 }
 199
 200 InsideHardwareReleaseReset::InsideHardwareReleaseReset(
 201     SharedRendererState* shared_renderer_state)
 202     : shared_renderer_state_(shared_renderer_state) {
 203   DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
 204   shared_renderer_state_->SetInsideHardwareRelease(true);
 205 }
 206
 207 InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
 208   shared_renderer_state_->SetInsideHardwareRelease(false);
 209 }
 210
 211 }  // namespace android_webview