Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/trees/layer_tree_impl.cc

 // 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.
 
 #include "cc/trees/layer_tree_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 516 matching lines @@
                                            root_layer_scroll_offset_delegate_,
                                            this));
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
   page_scale_layer_ = NULL;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
 }
 
-bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
+bool LayerTreeImpl::UpdateDrawProperties() {
   if (!needs_update_draw_properties_)
     return true;
 
-  // Calling UpdateDrawProperties must clear this flag, so there can be no
-  // early outs before this.
-  needs_update_draw_properties_ = false;
-
-  // For max_texture_size.  When the renderer is re-created in
-  // CreateAndSetRenderer, the needs update draw properties flag is set
-  // again.
+  // For max_texture_size.
   if (!layer_tree_host_impl_->renderer())
     return false;
 
-  // Clear this after the renderer early out, as it should still be
-  // possible to hit test even without a renderer.
-  render_surface_layer_list_.clear();
-
   if (!root_layer())
     return false;
 
+  needs_update_draw_properties_ = false;
+  render_surface_layer_list_.clear();
+
   {
     TRACE_EVENT2(
         "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
         "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_);
     LayerImpl* page_scale_layer =
         page_scale_layer_ ? page_scale_layer_ : InnerViewportContainerLayer();
     bool can_render_to_separate_surface =
         (layer_tree_host_impl_->GetDrawMode() !=
          DRAW_MODE_RESOURCELESS_SOFTWARE);
 
@@ skipping 79 matching lines @@
         }
       }
 
       occlusion_tracker.LeaveLayer(it);
     }
 
     unoccluded_screen_space_region_ =
         occlusion_tracker.ComputeVisibleRegionInScreen();
   }
 
-  // It'd be ideal if this could be done earlier, but when the raster source
-  // is updated from the main thread during push properties, update draw
-  // properties has not occurred yet and so it's not clear whether or not the
-  // layer can or cannot use lcd text.  So, this is the cleanup pass to
-  // determine if the raster source needs to be replaced with a non-lcd
-  // raster source due to draw properties.
-  if (update_lcd_text) {
-    // TODO(enne): Make LTHI::sync_tree return this value.
-    LayerTreeImpl* sync_tree =
-        layer_tree_host_impl_->proxy()->CommitToActiveTree()
-            ? layer_tree_host_impl_->active_tree()
-            : layer_tree_host_impl_->pending_tree();
-    // If this is not the sync tree, then it is not safe to update lcd text
-    // as it causes invalidations and the tiles may be in use.
-    DCHECK_EQ(this, sync_tree);
-    for (const auto& layer : picture_layers_)
-      layer->UpdateCanUseLCDTextAfterCommit();
-  }
-
   {
     TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
                        "IsActive", IsActiveTree(), "SourceFrameNumber",
                        source_frame_number_);
     const bool resourceless_software_draw =
         (layer_tree_host_impl_->GetDrawMode() ==
          DRAW_MODE_RESOURCELESS_SOFTWARE);
     size_t layers_updated_count = 0;
     bool tile_priorities_updated = false;
     for (PictureLayerImpl* layer : picture_layers_) {
@@ skipping 192 matching lines @@
 }
 
 bool LayerTreeImpl::IsPendingTree() const {
   return layer_tree_host_impl_->pending_tree() == this;
 }
 
 bool LayerTreeImpl::IsRecycleTree() const {
   return layer_tree_host_impl_->recycle_tree() == this;
 }
 
-bool LayerTreeImpl::IsSyncTree() const {
-  return layer_tree_host_impl_->sync_tree() == this;
-}
-
 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
   if (!tree)
     return NULL;
   return tree->LayerById(id);
 }
 
 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
   if (!tree)
@@ skipping 33 matching lines @@
 LayerTreeImpl::CreateScrollbarAnimationController(LayerImpl* scrolling_layer) {
   DCHECK(settings().scrollbar_fade_delay_ms);
   DCHECK(settings().scrollbar_fade_duration_ms);
   base::TimeDelta delay =
       base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_delay_ms);
   base::TimeDelta resize_delay = base::TimeDelta::FromMilliseconds(
       settings().scrollbar_fade_resize_delay_ms);
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_duration_ms);
   switch (settings().scrollbar_animator) {
-    case LayerTreeSettings::LINEAR_FADE: {
+    case LayerTreeSettings::LinearFade: {
       return ScrollbarAnimationControllerLinearFade::Create(
           scrolling_layer,
           layer_tree_host_impl_,
           delay,
           resize_delay,
           duration);
     }
-    case LayerTreeSettings::THINNING: {
+    case LayerTreeSettings::Thinning: {
       return ScrollbarAnimationControllerThinning::Create(scrolling_layer,
                                                           layer_tree_host_impl_,
                                                           delay,
                                                           resize_delay,
                                                           duration);
     }
-    case LayerTreeSettings::NO_ANIMATOR:
+    case LayerTreeSettings::NoAnimator:
       NOTREACHED();
       break;
   }
   return nullptr;
 }
 
 void LayerTreeImpl::DidAnimateScrollOffset() {
   layer_tree_host_impl_->DidAnimateScrollOffset();
 }
 
@@ skipping 213 matching lines @@
   return layer_tree_host_impl_->ResourceIdForUIResource(uid);
 }
 
 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid) const {
   return layer_tree_host_impl_->IsUIResourceOpaque(uid);
 }
 
 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
   for (const auto& req : ui_resource_request_queue_) {
     switch (req.GetType()) {
-      case UIResourceRequest::UI_RESOURCE_CREATE:
+      case UIResourceRequest::UIResourceCreate:
         layer_tree_host_impl_->CreateUIResource(req.GetId(), req.GetBitmap());
         break;
-      case UIResourceRequest::UI_RESOURCE_DELETE:
+      case UIResourceRequest::UIResourceDelete:
         layer_tree_host_impl_->DeleteUIResource(req.GetId());
         break;
-      case UIResourceRequest::UI_RESOURCE_INVALID_REQUEST:
+      case UIResourceRequest::UIResourceInvalidRequest:
         NOTREACHED();
         break;
     }
   }
   ui_resource_request_queue_.clear();
 
   // If all UI resource evictions were not recreated by processing this queue,
   // then another commit is required.
   if (layer_tree_host_impl_->EvictedUIResourcesExist())
     layer_tree_host_impl_->SetNeedsCommit();
@@ skipping 273 matching lines @@
            ScrollsAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty() ||
            layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  if (!UpdateDrawProperties())
     return NULL;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point,
                            root_layer(),
                            HitTestVisibleScrollableOrTouchableFunctor(),
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
@@ skipping 21 matching lines @@
 struct FindWheelEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  if (!UpdateDrawProperties())
     return NULL;
   FindWheelEventLayerFunctor func;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point, root_layer(), func,
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return LayerHasTouchEventHandlersAt(screen_space_point, layer);
   }
   const gfx::PointF screen_space_point;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  if (!UpdateDrawProperties())
     return NULL;
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelectionBound& start,
                                       const LayerSelectionBound& end) {
@@ skipping 84 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc