Allow layers to signal that additional sequences are needed before surface destruction

ui/compositor/compositor.cc

 // Copyright (c) 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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 45 matching lines @@
   CancelLock();
 }
 
 void CompositorLock::CancelLock() {
   if (!compositor_)
     return;
   compositor_->UnlockCompositor();
   compositor_ = NULL;
 }
 
-}  // namespace ui
-
-namespace {}  // namespace
-
-namespace ui {
-
-class SatisfySwapPromise : public cc::SwapPromise {
- public:
-  explicit SatisfySwapPromise(uint32_t id) : id_(id) {}
-
- private:
-  void DidSwap(cc::CompositorFrameMetadata* metadata) override {
-    metadata->satisfies_sequences.push_back(id_);
-  }
-
-  void DidNotSwap(DidNotSwapReason reason) override {
-    // TODO(jbauman): Send to the SurfaceManager immediately.
-    DCHECK(false);
-  }
-  int64 TraceId() const override { return 0; }
-  uint32_t id_;
-};
-
 Compositor::Compositor(gfx::AcceleratedWidget widget,
                        ui::ContextFactory* context_factory,
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       root_layer_(NULL),
       widget_(widget),
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
-      surface_sequence_number_(0),
       compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       defer_draw_scheduling_(false),
       waiting_on_compositing_end_(false),
@@ skipping 67 matching lines @@
         this,
         this,
         context_factory_->GetSharedBitmapManager(),
         context_factory_->GetGpuMemoryBufferManager(),
         settings,
         task_runner_);
   }
   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
                       base::TimeTicks::Now() - before_create);
   host_->SetRootLayer(root_web_layer_);
+  host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
   host_->SetLayerTreeHostClientReady();
 }
 
 Compositor::~Compositor() {
   TRACE_EVENT0("shutdown", "Compositor::destructor");
 
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
   if (root_layer_)
@@ skipping 235 matching lines @@
 
 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
   return host_->debug_state();
 }
 
 void Compositor::SetLayerTreeDebugState(
     const cc::LayerTreeDebugState& debug_state) {
   host_->SetDebugState(debug_state);
 }
 
-cc::SurfaceSequence Compositor::InsertSurfaceSequenceForNextFrame() {
-  cc::SurfaceSequence sequence;
-  sequence.id_namespace = surface_id_allocator_->id_namespace();
-  sequence.sequence = ++surface_sequence_number_;
-  scoped_ptr<cc::SwapPromise> promise(
-      new SatisfySwapPromise(surface_sequence_number_));
-  host_->QueueSwapPromise(promise.Pass());
-  return sequence;
-}
-
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
   if (!compositor_lock_) {
     compositor_lock_ = new CompositorLock(this);
     if (compositor_thread_loop_.get())
       host_->SetDeferCommits(true);
     FOR_EACH_OBSERVER(CompositorObserver,
                       observer_list_,
                       OnCompositingLockStateChanged(this));
   }
   return compositor_lock_;
@@ skipping 24 matching lines @@
     // Call ScheduleDraw() instead of Draw() in order to allow other
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(
       CompositorObserver, observer_list_, OnCompositingEnded(this));
 }
 
 }  // namespace ui