ui: Cleanup ui::Layer

ui/compositor/layer.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 266 matching lines @@
   // Adds |invalid_rect| to the Layer's pending invalid rect and calls
   // ScheduleDraw(). Returns false if the paint request is ignored.
   bool SchedulePaint(const gfx::Rect& invalid_rect);
 
   // Schedules a redraw of the layer tree at the compositor.
   // Note that this _does not_ invalidate any region of this layer; use
   // SchedulePaint() for that.
   void ScheduleDraw();
 
   // Sends damaged rectangles recorded in |damaged_region_| to
-  // |compostior_| to repaint the content.
+  // |cc_layer_| to update dirty rect.

[danakj, 2014/01/16 19:48:29]

// Uses damaged rectangles recorded in |damaged_region_| to invalidate the
|cc_layer_|.

[simonhong, 2014/01/16 20:59:59]

Done.

   void SendDamagedRects();
 
   const SkRegion& damaged_region() const { return damaged_region_; }
 
-  // Suppresses painting the content by disgarding damaged region and ignoring
-  // new paint requests.
+  // Suppresses painting the content by deleting |delegate_|.

[danakj, 2014/01/16 19:48:29]

This disconnects the delegate - it doesn't delete it.

[simonhong, 2014/01/16 20:59:59]

Modified to disconnecting |delegate_|.

   void SuppressPaint();
 
   // Notifies the layer that the device scale factor has changed.
   void OnDeviceScaleFactorChanged(float device_scale_factor);
 
   // Sets whether the layer should scale its content. If true, the canvas will
   // be scaled in software rendering mode before it is passed to
-  // |LayerDelegate::OnPaint|.
+  // |LayerDelegate::OnPaintLayer|.
   // Set to false if the delegate handles scaling.
   // NOTE: if this is called during |LayerDelegate::OnPaint|, the new value will
   // not apply to the canvas passed to the pending draw.
   void set_scale_content(bool scale_content) { scale_content_ = scale_content; }
 
   // Returns true if the layer scales its content.
   bool scale_content() const { return scale_content_; }
 
-  // Sometimes the Layer is being updated by something other than SetCanvas
-  // (e.g. the GPU process on UI_COMPOSITOR_IMAGE_TRANSPORT).
-  bool layer_updated_externally() const { return layer_updated_externally_; }
-
   // Requets a copy of the layer's output as a texture or bitmap.
   void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
   // ContentLayerClient
   virtual void PaintContents(
       SkCanvas* canvas, const gfx::Rect& clip, gfx::RectF* opaque) OVERRIDE;
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
 
   cc::Layer* cc_layer() { return cc_layer_; }
 
   // TextureLayerClient
   virtual unsigned PrepareTexture() OVERRIDE;
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
       scoped_ptr<cc::SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE;
 
   float device_scale_factor() const { return device_scale_factor_; }
 
   // Forces a render surface to be used on this layer. This has no positive
   // impact, and is only used for benchmarking/testing purpose.
   void SetForceRenderSurface(bool force);
   bool force_render_surface() const { return force_render_surface_; }
 
   // LayerClient
   virtual std::string DebugName() OVERRIDE;
-
   virtual scoped_refptr<base::debug::ConvertableToTraceFormat>
       TakeDebugInfo() OVERRIDE;
 
   // LayerAnimationEventObserver
   virtual void OnAnimationStarted(const cc::AnimationEvent& event) OVERRIDE;
 
   // Whether this layer has animations waiting to get sent to its cc::Layer.
   bool HasPendingThreadedAnimations() {
     return pending_threaded_animations_.size() != 0;
   }
 
   // Triggers a call to SwitchToLayer.
   void SwitchCCLayerForTest();
 
  private:
   // Stacks |child| above or below |other|.  Helper method for StackAbove() and
   // StackBelow().
   void StackRelativeTo(Layer* child, Layer* other, bool above);
 
   bool ConvertPointForAncestor(const Layer* ancestor, gfx::Point* point) const;
   bool ConvertPointFromAncestor(const Layer* ancestor, gfx::Point* point) const;
 
-  // Following are invoked from the animation or if no animation exists to
-  // update the values immediately.
-  void SetBoundsImmediately(const gfx::Rect& bounds);
-  void SetTransformImmediately(const gfx::Transform& transform);
-  void SetOpacityImmediately(float opacity);
-  void SetVisibilityImmediately(bool visibility);
-  void SetBrightnessImmediately(float brightness);
-  void SetGrayscaleImmediately(float grayscale);
-  void SetColorImmediately(SkColor color);
-
   // Implementation of LayerAnimatorDelegate
   virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE;
   virtual void SetTransformFromAnimation(
       const gfx::Transform& transform) OVERRIDE;
   virtual void SetOpacityFromAnimation(float opacity) OVERRIDE;
   virtual void SetVisibilityFromAnimation(bool visibility) OVERRIDE;
   virtual void SetBrightnessFromAnimation(float brightness) OVERRIDE;
   virtual void SetGrayscaleFromAnimation(float grayscale) OVERRIDE;
   virtual void SetColorFromAnimation(SkColor color) OVERRIDE;
   virtual void ScheduleDrawForAnimation() OVERRIDE;
   virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE;
   virtual gfx::Transform GetTransformForAnimation() const OVERRIDE;
   virtual float GetOpacityForAnimation() const OVERRIDE;
   virtual bool GetVisibilityForAnimation() const OVERRIDE;
   virtual float GetBrightnessForAnimation() const OVERRIDE;
   virtual float GetGrayscaleForAnimation() const OVERRIDE;
   virtual SkColor GetColorForAnimation() const OVERRIDE;
   virtual float GetDeviceScaleFactor() const OVERRIDE;
   virtual void AddThreadedAnimation(
       scoped_ptr<cc::Animation> animation) OVERRIDE;
   virtual void RemoveThreadedAnimation(int animation_id) OVERRIDE;
 
+  // Creates a corresponding composited layer for |type_|.
   void CreateWebLayer();
+
+  // Recomputes and sets to |cc_layer_|.
   void RecomputeCCTransformFromTransform(const gfx::Transform& transform);
   void RecomputeDrawsContentAndUVRect();
   void RecomputePosition();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
 
-  void UpdateIsDrawn();
-
+  // Cleanup |cc_layer_| and replaces it with |new_layer|.
   void SwitchToLayer(scoped_refptr<cc::Layer> new_layer);
 
   // We cannot send animations to our cc_layer_ until we have been added to a
   // layer tree. Instead, we hold on to these animations in
   // pending_threaded_animations_, and expect SendPendingThreadedAnimations to
   // be called once we have been added to a tree.
   void SendPendingThreadedAnimations();
 
   const LayerType type_;
 
   Compositor* compositor_;
 
   scoped_refptr<ui::Texture> texture_;
 
   Layer* parent_;
 
   // This layer's children, in bottom-to-top stacking order.
   std::vector<Layer*> children_;
 
   gfx::Rect bounds_;
 
   // Visibility of this layer. See SetVisible/IsDrawn for more details.
   bool visible_;
 
+  // See SetForceRenderSurface() for more details.

[danakj, 2014/01/16 19:48:29]

Is this really needed?

[simonhong, 2014/01/16 20:59:59]

No.. I think it's redundant. Removed.

   bool force_render_surface_;
 
   bool fills_bounds_opaquely_;
 
-  // If true the layer is always up to date.
-  bool layer_updated_externally_;
-
   // Union of damaged rects, in pixel coordinates, to be used when
   // compositor is ready to paint the content.
   SkRegion damaged_region_;
 
   int background_blur_radius_;
 
   // Several variables which will change the visible representation of
   // the layer.
   float layer_saturation_;
   float layer_brightness_;
@@ skipping 48 matching lines @@
   // The size of the delegated frame in DIP, set when SetShowDelegatedContent
   // was called.
   gfx::Size delegated_frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_