Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/trees/layer_tree_host.cc

Index: cc/trees/layer_tree_host.cc
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 49e374d94690516e8c0fbefec167c1cc03c4650f..f4780789394c447a1b3a56cfb5925ef325dec6a1 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -133,6 +133,7 @@ LayerTreeHost::LayerTreeHost(
       partial_texture_update_requests_(0),
       did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
+      total_frames_used_for_lcd_text_metrics_(0),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(shared_bitmap_manager),
@@ -232,10 +233,6 @@ void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
 }
 
-void LayerTreeHost::BeginMainFrameNotExpectedSoon() {
-  client_->BeginMainFrameNotExpectedSoon();
-}
-
 void LayerTreeHost::BeginMainFrame(const BeginFrameArgs& args) {
   inside_begin_main_frame_ = true;
   client_->BeginMainFrame(args);
@@ -562,19 +559,19 @@ void LayerTreeHost::SetAnimationEvents(
         animation_controllers.find(event_layer_id);
     if (iter != animation_controllers.end()) {
       switch ((*events)[event_index].type) {
-        case AnimationEvent::STARTED:
+        case AnimationEvent::Started:
           (*iter).second->NotifyAnimationStarted((*events)[event_index]);
           break;
 
-        case AnimationEvent::FINISHED:
+        case AnimationEvent::Finished:
           (*iter).second->NotifyAnimationFinished((*events)[event_index]);
           break;
 
-        case AnimationEvent::ABORTED:
+        case AnimationEvent::Aborted:
           (*iter).second->NotifyAnimationAborted((*events)[event_index]);
           break;
 
-        case AnimationEvent::PROPERTY_UPDATE:
+        case AnimationEvent::PropertyUpdate:
           (*iter).second->NotifyAnimationPropertyUpdate((*events)[event_index]);
           break;
       }
@@ -812,6 +809,18 @@ void LayerTreeHost::RecordGpuRasterizationHistogram() {
   gpu_rasterization_histogram_recorded_ = true;
 }
 
+void LayerTreeHost::CalculateLCDTextMetricsCallback(Layer* layer) {
+  if (!layer->SupportsLCDText())
+    return;
+
+  lcd_text_metrics_.total_num_cc_layers++;
+  if (layer->draw_properties().can_use_lcd_text) {
+    lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text++;
+    if (layer->contents_opaque())
+      lcd_text_metrics_.total_num_cc_layers_will_use_lcd_text++;
+  }
+}
+
 bool LayerTreeHost::UsingSharedMemoryResources() {
   return GetRendererCapabilities().using_shared_memory_resources;
 }
@@ -852,6 +861,29 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
         settings_.verify_property_trees, &update_list,
         render_surface_layer_list_id);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+
+    if (total_frames_used_for_lcd_text_metrics_ <=
+        kTotalFramesToUseForLCDTextMetrics) {
+      LayerTreeHostCommon::CallFunctionForSubtree(
+          root_layer,
+          base::Bind(&LayerTreeHost::CalculateLCDTextMetricsCallback,
+                     base::Unretained(this)));
+      total_frames_used_for_lcd_text_metrics_++;
+    }
+
+    if (total_frames_used_for_lcd_text_metrics_ ==
+        kTotalFramesToUseForLCDTextMetrics) {
+      total_frames_used_for_lcd_text_metrics_++;
+
+      UMA_HISTOGRAM_PERCENTAGE(
+          "Renderer4.LCDText.PercentageOfCandidateLayers",
+          lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text * 100.0 /
+          lcd_text_metrics_.total_num_cc_layers);
+      UMA_HISTOGRAM_PERCENTAGE(
+          "Renderer4.LCDText.PercentageOfAALayers",
+          lcd_text_metrics_.total_num_cc_layers_will_use_lcd_text * 100.0 /
+          lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text);
+    }
   }
 
   // Reset partial texture update requests.
@@ -1219,7 +1251,8 @@ UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
          ui_resource_client_map_.end());
 
   bool resource_lost = false;
-  UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, next_id,
+  UIResourceRequest request(UIResourceRequest::UIResourceCreate,
+                            next_id,
                             client->GetBitmap(next_id, resource_lost));
   ui_resource_request_queue_.push_back(request);
 
@@ -1237,7 +1270,7 @@ void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
   if (iter == ui_resource_client_map_.end())
     return;
 
-  UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
+  UIResourceRequest request(UIResourceRequest::UIResourceDelete, uid);
   ui_resource_request_queue_.push_back(request);
   ui_resource_client_map_.erase(iter);
 }
@@ -1249,7 +1282,8 @@ void LayerTreeHost::RecreateUIResources() {
     UIResourceId uid = iter->first;
     const UIResourceClientData& data = iter->second;
     bool resource_lost = true;
-    UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
+    UIResourceRequest request(UIResourceRequest::UIResourceCreate,
+                              uid,
                               data.client->GetBitmap(uid, resource_lost));
     ui_resource_request_queue_.push_back(request);
   }