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       needs_force_invalidate_on_next_draw_gl_(false),
  83       weak_factory_on_ui_thread_(this) {
  84   DCHECK(ui_loop_->BelongsToCurrentThread());
  85   DCHECK(client_on_ui_);
  86   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
  87   ResetRequestDrawGLCallback();
  88 }
  89
  90 SharedRendererState::~SharedRendererState() {
  91   DCHECK(ui_loop_->BelongsToCurrentThread());
  92 }
  93
  94 void SharedRendererState::ClientRequestDrawGL() {
  95   if (ui_loop_->BelongsToCurrentThread()) {
  96     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnUiThread(this))
  97       return;
  98     ClientRequestDrawGLOnUIThread();
  99   } else {
 100     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNoneUiThread(this))
 101       return;
 102     base::Closure callback;
 103     {
 104       base::AutoLock lock(lock_);
 105       callback = request_draw_gl_closure_;
 106     }
 107     ui_loop_->PostTask(FROM_HERE, callback);
 108   }
 109 }
 110
 111 void SharedRendererState::DidDrawGLProcess() {
 112   g_request_draw_gl_tracker.Get().ResetPending();
 113 }
 114
 115 void SharedRendererState::ResetRequestDrawGLCallback() {
 116   DCHECK(ui_loop_->BelongsToCurrentThread());
 117   base::AutoLock lock(lock_);
 118   request_draw_gl_cancelable_closure_.Reset(
 119       base::Bind(&SharedRendererState::ClientRequestDrawGLOnUIThread,
 120                  base::Unretained(this)));
 121   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 122 }
 123
 124 void SharedRendererState::ClientRequestDrawGLOnUIThread() {
 125   DCHECK(ui_loop_->BelongsToCurrentThread());
 126   ResetRequestDrawGLCallback();
 127   if (!client_on_ui_->RequestDrawGL(NULL, false)) {
 128     g_request_draw_gl_tracker.Get().ResetPending();
 129     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
 130   }
 131 }
 132
 133 void SharedRendererState::UpdateParentDrawConstraintsOnUIThread() {
 134   DCHECK(ui_loop_->BelongsToCurrentThread());
 135   client_on_ui_->UpdateParentDrawConstraints();
 136 }
 137
 138 bool SharedRendererState::HasDrawGLInput() const {
 139   base::AutoLock lock(lock_);
 140   return draw_gl_input_.get();
 141 }
 142
 143 void SharedRendererState::SetDrawGLInput(scoped_ptr<DrawGLInput> input) {
 144   base::AutoLock lock(lock_);
 145   DCHECK(!draw_gl_input_.get());
 146   draw_gl_input_ = input.Pass();
 147 }
 148
 149 scoped_ptr<DrawGLInput> SharedRendererState::PassDrawGLInput() {
 150   base::AutoLock lock(lock_);
 151   return draw_gl_input_.Pass();
 152 }
 153
 154 bool SharedRendererState::UpdateDrawConstraints(
 155     const ParentCompositorDrawConstraints& parent_draw_constraints) {
 156   base::AutoLock lock(lock_);
 157   if (needs_force_invalidate_on_next_draw_gl_ ||
 158       !parent_draw_constraints_.Equals(parent_draw_constraints)) {
 159     parent_draw_constraints_ = parent_draw_constraints;
 160     return true;
 161   }
 162
 163   return false;
 164 }
 165
 166 void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
 167     const ParentCompositorDrawConstraints& parent_draw_constraints) {
 168   if (UpdateDrawConstraints(parent_draw_constraints)) {
 169     // No need to hold the lock_ during the post task.
 170     ui_loop_->PostTask(
 171         FROM_HERE,
 172         base::Bind(&SharedRendererState::UpdateParentDrawConstraintsOnUIThread,
 173                    ui_thread_weak_ptr_));
 174   }
 175 }
 176
 177 const ParentCompositorDrawConstraints
 178 SharedRendererState::ParentDrawConstraints() const {
 179   base::AutoLock lock(lock_);
 180   return parent_draw_constraints_;
 181 }
 182
 183 void SharedRendererState::SetForceInvalidateOnNextDrawGL(
 184     bool needs_force_invalidate_on_next_draw_gl) {
 185   base::AutoLock lock(lock_);
 186   needs_force_invalidate_on_next_draw_gl_ =
 187       needs_force_invalidate_on_next_draw_gl;
 188 }
 189
 190 bool SharedRendererState::NeedsForceInvalidateOnNextDrawGL() const {
 191   base::AutoLock lock(lock_);
 192   return needs_force_invalidate_on_next_draw_gl_;
 193 }
 194
 195 void SharedRendererState::SetInsideHardwareRelease(bool inside) {
 196   base::AutoLock lock(lock_);
 197   inside_hardware_release_ = inside;
 198 }
 199
 200 bool SharedRendererState::IsInsideHardwareRelease() const {
 201   base::AutoLock lock(lock_);
 202   return inside_hardware_release_;
 203 }
 204
 205 void SharedRendererState::InsertReturnedResources(
 206     const cc::ReturnedResourceArray& resources) {
 207   base::AutoLock lock(lock_);
 208   returned_resources_.insert(
 209       returned_resources_.end(), resources.begin(), resources.end());
 210 }
 211
 212 void SharedRendererState::SwapReturnedResources(
 213     cc::ReturnedResourceArray* resources) {
 214   DCHECK(resources->empty());
 215   base::AutoLock lock(lock_);
 216   resources->swap(returned_resources_);
 217 }
 218
 219 bool SharedRendererState::ReturnedResourcesEmpty() const {
 220   base::AutoLock lock(lock_);
 221   return returned_resources_.empty();
 222 }
 223
 224 InsideHardwareReleaseReset::InsideHardwareReleaseReset(
 225     SharedRendererState* shared_renderer_state)
 226     : shared_renderer_state_(shared_renderer_state) {
 227   DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
 228   shared_renderer_state_->SetInsideHardwareRelease(true);
 229 }
 230
 231 InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
 232   shared_renderer_state_->SetInsideHardwareRelease(false);
 233 }
 234
 235 }  // namespace android_webview