Upstream version 9.37.195.0

[platform/framework/web/crosswalk.git] / src / android_webview / browser / shared_renderer_state.cc

diff --git a/src/android_webview/browser/shared_renderer_state.cc b/src/android_webview/browser/shared_renderer_state.cc
index 3483d63..582908e 100644 (file)
--- a/src/android_webview/browser/shared_renderer_state.cc
+++ b/src/android_webview/browser/shared_renderer_state.cc
@@ -10,9 +10,11 @@
 
 namespace android_webview {
 
-DrawGLInput::DrawGLInput() : frame_id(0), width(0), height(0) {}
+DrawGLInput::DrawGLInput() : width(0), height(0) {
+}
 
-DrawGLResult::DrawGLResult() : frame_id(0), clip_contains_visible_rect(false) {}
+DrawGLInput::~DrawGLInput() {
+}
 
 SharedRendererState::SharedRendererState(
     scoped_refptr<base::MessageLoopProxy> ui_loop,
@@ -21,14 +23,15 @@ SharedRendererState::SharedRendererState(
       client_on_ui_(client),
       weak_factory_on_ui_thread_(this),
       ui_thread_weak_ptr_(weak_factory_on_ui_thread_.GetWeakPtr()),
-      compositor_(NULL),
-      memory_policy_dirty_(false),
-      hardware_initialized_(false) {
+      inside_hardware_release_(false),
+      share_context_(NULL) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(client_on_ui_);
 }
 
-SharedRendererState::~SharedRendererState() {}
+SharedRendererState::~SharedRendererState() {
+  DCHECK(ui_loop_->BelongsToCurrentThread());
+}
 
 void SharedRendererState::ClientRequestDrawGL() {
   if (ui_loop_->BelongsToCurrentThread()) {
@@ -48,85 +51,67 @@ void SharedRendererState::ClientRequestDrawGLOnUIThread() {
   }
 }
 
-void SharedRendererState::SetCompositorOnUiThread(
-    content::SynchronousCompositor* compositor) {
+void SharedRendererState::SetDrawGLInput(scoped_ptr<DrawGLInput> input) {
   base::AutoLock lock(lock_);
-  DCHECK(ui_loop_->BelongsToCurrentThread());
-  compositor_ = compositor;
+  DCHECK(!draw_gl_input_.get());
+  draw_gl_input_ = input.Pass();
 }
 
-content::SynchronousCompositor* SharedRendererState::GetCompositor() {
+scoped_ptr<DrawGLInput> SharedRendererState::PassDrawGLInput() {
   base::AutoLock lock(lock_);
-  DCHECK(compositor_);
-  return compositor_;
+  return draw_gl_input_.Pass();
 }
 
-void SharedRendererState::SetMemoryPolicy(
-    const content::SynchronousCompositorMemoryPolicy new_policy) {
+void SharedRendererState::SetInsideHardwareRelease(bool inside) {
   base::AutoLock lock(lock_);
-  if (memory_policy_ != new_policy) {
-    memory_policy_ = new_policy;
-    memory_policy_dirty_ = true;
-  }
+  inside_hardware_release_ = inside;
 }
 
-content::SynchronousCompositorMemoryPolicy
-SharedRendererState::GetMemoryPolicy() const {
+bool SharedRendererState::IsInsideHardwareRelease() const {
   base::AutoLock lock(lock_);
-  return memory_policy_;
+  return inside_hardware_release_;
 }
 
-void SharedRendererState::SetDrawGLInput(const DrawGLInput& input) {
+void SharedRendererState::SetSharedContext(gpu::GLInProcessContext* context) {
   base::AutoLock lock(lock_);
-  draw_gl_input_ = input;
+  DCHECK(!share_context_ || !context);
+  share_context_ = context;
 }
 
-DrawGLInput SharedRendererState::GetDrawGLInput() const {
+gpu::GLInProcessContext* SharedRendererState::GetSharedContext() const {
   base::AutoLock lock(lock_);
-  return draw_gl_input_;
+  DCHECK(share_context_);
+  return share_context_;
 }
 
-void SharedRendererState::ClearClosureQueue() {
+void SharedRendererState::InsertReturnedResources(
+    const cc::ReturnedResourceArray& resources) {
   base::AutoLock lock(lock_);
-  std::queue<base::Closure> empty;
-  std::swap(closure_queue_, empty);
+  returned_resources_.insert(
+      returned_resources_.end(), resources.begin(), resources.end());
 }
 
-void SharedRendererState::AppendClosure(const base::Closure& closure) {
+void SharedRendererState::SwapReturnedResources(
+    cc::ReturnedResourceArray* resources) {
+  DCHECK(resources->empty());
   base::AutoLock lock(lock_);
-  closure_queue_.push(closure);
+  resources->swap(returned_resources_);
 }
 
-base::Closure SharedRendererState::PopFrontClosure() {
-  base::Closure closure;
-
+bool SharedRendererState::ReturnedResourcesEmpty() const {
   base::AutoLock lock(lock_);
-  if (!closure_queue_.empty()) {
-    closure = closure_queue_.front();
-    closure_queue_.pop();
-  }
-
-  return closure;
+  return returned_resources_.empty();
 }
 
-void SharedRendererState::SetHardwareInitialized(bool initialized) {
-  base::AutoLock lock(lock_);
-  hardware_initialized_ = initialized;
-}
-
-bool SharedRendererState::IsHardwareInitialized() const {
-  base::AutoLock lock(lock_);
-  return hardware_initialized_;
+InsideHardwareReleaseReset::InsideHardwareReleaseReset(
+    SharedRendererState* shared_renderer_state)
+    : shared_renderer_state_(shared_renderer_state) {
+  DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
+  shared_renderer_state_->SetInsideHardwareRelease(true);
 }
 
-void SharedRendererState::SetMemoryPolicyDirty(bool is_dirty) {
-  base::AutoLock lock(lock_);
-  memory_policy_dirty_ = is_dirty;
-}
-
-bool SharedRendererState::IsMemoryPolicyDirty() const {
-  base::AutoLock lock(lock_);
-  return memory_policy_dirty_;
+InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
+  shared_renderer_state_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview