cc: Update Main RendererCapabilities on DeferredInitialize

cc/trees/thread_proxy.h

 // Copyright 2011 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.
 
 #ifndef CC_TREES_THREAD_PROXY_H_
 #define CC_TREES_THREAD_PROXY_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 53 matching lines @@
   virtual void Start() OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
   virtual void AcquireLayerTextures() OVERRIDE;
   virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
   virtual scoped_ptr<base::Value> AsValue() const OVERRIDE;
   virtual bool CommitPendingForTesting() OVERRIDE;
   virtual scoped_ptr<base::Value> SchedulerStateAsValueForTesting() OVERRIDE;
 
   // LayerTreeHostImplClient implementation
+  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE;
   virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
   virtual void DidSwapBuffersOnImplThread() OVERRIDE {}
   virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE;
   virtual void BeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
   virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
   virtual void NotifyReadyToActivate() OVERRIDE;
   // Please call these 2 functions through
   // LayerTreeHostImpl's SetNeedsRedraw() and SetNeedsRedrawRect().
   virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
   virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect)
@@ skipping 48 matching lines @@
     ~BeginMainFrameAndCommitState();
 
     base::TimeTicks monotonic_frame_begin_time;
     scoped_ptr<ScrollAndScaleSet> scroll_info;
     size_t memory_allocation_limit_bytes;
     int memory_allocation_priority_cutoff;
     bool evicted_ui_resources;
   };
 
   // Called on main thread.
+  void SetRendererCapabilitiesMainThreadCopy(
+      const RendererCapabilities& capabilities);
   void BeginMainFrame(
       scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state);
   void DidCommitAndDrawFrame();
   void DidCompleteSwapBuffers();
   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue,
                           base::Time wall_clock_time);
   void DoCreateAndInitializeOutputSurface();
   // |capabilities| is set only when |success| is true.
   void OnOutputSurfaceInitializeAttempted(
       bool success,
       const RendererCapabilities& capabilities);
   void SendCommitRequestToImplThreadIfNeeded();
 
   // Called on impl thread.
   struct ReadbackRequest;
   struct CommitPendingRequest;
   struct SchedulerStateRequest;
 
   void ForceCommitForReadbackOnImplThread(
       CompletionEvent* begin_main_frame_sent_completion,
       ReadbackRequest* request);
   void StartCommitOnImplThread(
       CompletionEvent* completion,
       ResourceUpdateQueue* queue,
-      scoped_refptr<ContextProvider> offscreen_context_provider);
+      scoped_refptr<ContextProvider> offscreen_context_provider,
+      const RendererCapabilities& main_frame_renderer_caps);
   void BeginMainFrameAbortedOnImplThread(bool did_handle);
   void RequestReadbackOnImplThread(ReadbackRequest* request);
   void FinishAllRenderingOnImplThread(CompletionEvent* completion);
   void InitializeImplOnImplThread(CompletionEvent* completion,
                                   int layer_tree_host_id);
   void SetLayerTreeHostClientReadyOnImplThread();
   void SetVisibleOnImplThread(CompletionEvent* completion, bool visible);
   void UpdateBackgroundAnimateTicking();
   void HasInitializedOutputSurfaceOnImplThread(
       CompletionEvent* completion,
@@ skipping 90 matching lines @@
     // Set when the main thread is waiting on a
     // ScheduledActionSendBeginMainFrame to be issued.
     CompletionEvent* begin_main_frame_sent_completion_event;
 
     // Set when the main thread is waiting on a readback.
     ReadbackRequest* readback_request;
 
     // Set when the main thread is waiting on a commit to complete.
     CompletionEvent* commit_completion_event;
 
+    // The main renderer capabilities used for this commit. used to check
+    // for renderer capability staleness.
+    RendererCapabilities renderer_capabilities_for_commit;
+
     // Set when the main thread is waiting on a pending tree activation.
     CompletionEvent* completion_event_for_commit_held_on_tree_activation;
 
     // Set when the main thread is waiting on layers to be drawn.
     CompletionEvent* texture_acquisition_completion_event;
 
     scoped_ptr<ResourceUpdateController> current_resource_update_controller;
 
     // Set when the next draw should post DidCommitAndDrawFrame to the main
     // thread.
@@ skipping 30 matching lines @@
 
   base::WeakPtr<ThreadProxy> main_thread_weak_ptr_;
   base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadProxy);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_THREAD_PROXY_H_