Remove CompositorObserver::OnCompositingEnded()

ui/compositor/layer_unittest.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/layer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 192 matching lines @@
       const gfx::Rect& bounds, DrawStringLayerDelegate* delegate) {
     std::unique_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
     layer->SetBounds(bounds);
     layer->set_delegate(delegate);
     return layer;
   }
 
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
-    WaitForSwap();
+    WaitForDraw();
   }
 
   void ReadPixels(SkBitmap* bitmap) {
     ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
   }
 
   void ReadPixels(SkBitmap* bitmap, gfx::Rect source_rect) {
     scoped_refptr<ReadbackHolder> holder(new ReadbackHolder);
     std::unique_ptr<cc::CopyOutputRequest> request =
         cc::CopyOutputRequest::CreateBitmapRequest(
@@ skipping 13 matching lines @@
     // Waits for the callback to finish run and return result.
     holder->WaitForReadback();
 
     *bitmap = holder->result();
   }
 
   void WaitForDraw() {
     ui::DrawWaiterForTest::WaitForCompositingStarted(GetCompositor());
   }
 
-  void WaitForSwap() {
-    DrawWaiterForTest::WaitForCompositingEnded(GetCompositor());
-  }
+  // void WaitForSwap() {

[Fady Samuel, 2017/03/27 18:36:18]

Delete this?

[Alex Z., 2017/03/27 18:52:38]

Done.

+  //   DrawWaiterForTest::WaitForCompositingEnded(GetCompositor());
+  // }
 
   void WaitForCommit() {
     ui::DrawWaiterForTest::WaitForCommit(GetCompositor());
   }
 
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
@@ skipping 123 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
   TestCompositorObserver() = default;
 
   bool committed() const { return committed_; }
-  bool notified() const { return started_ && ended_; }
+  bool started() const { return started_; }
 
   void Reset() {
     committed_ = false;
     started_ = false;
-    ended_ = false;
   }
 
  private:
   void OnCompositingDidCommit(Compositor* compositor) override {
     committed_ = true;
   }
 
   void OnCompositingStarted(Compositor* compositor,
                             base::TimeTicks start_time) override {
     started_ = true;
   }
 
-  void OnCompositingEnded(Compositor* compositor) override { ended_ = true; }
-
   void OnCompositingLockStateChanged(Compositor* compositor) override {}
 
   void OnCompositingShuttingDown(Compositor* compositor) override {}
 
   bool committed_ = false;
   bool started_ = false;
-  bool ended_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 };
 
 class TestCompositorAnimationObserver : public CompositorAnimationObserver {
  public:
   explicit TestCompositorAnimationObserver(ui::Compositor* compositor)
       : compositor_(compositor),
         animation_step_count_(0),
         shutdown_(false) {
@@ skipping 902 matching lines @@
       CreateColorLayer(SK_ColorRED, gfx::Rect(20, 20, 400, 400)));
   std::unique_ptr<Layer> l2(
       CreateColorLayer(SK_ColorBLUE, gfx::Rect(10, 10, 350, 350)));
   l1->Add(l2.get());
   TestCompositorObserver observer;
   GetCompositor()->AddObserver(&observer);
 
   // Explicitly called DrawTree should cause the observers to be notified.
   // NOTE: this call to DrawTree sets l1 to be the compositor's root layer.
   DrawTree(l1.get());
-  EXPECT_TRUE(observer.notified());
+  EXPECT_TRUE(observer.started());
 
   // ScheduleDraw without any visible change should cause a commit.
   observer.Reset();
   l1->ScheduleDraw();
   WaitForCommit();
   EXPECT_TRUE(observer.committed());
 
   // Moving, but not resizing, a layer should alert the observers.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 350, 350));
-  WaitForSwap();
-  EXPECT_TRUE(observer.notified());
+  WaitForDraw();
+  EXPECT_TRUE(observer.started());
 
   // So should resizing a layer.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 400, 400));
-  WaitForSwap();
-  EXPECT_TRUE(observer.notified());
+  WaitForDraw();
+  EXPECT_TRUE(observer.started());
 
   // Opacity changes should alert the observers.
   observer.Reset();
   l2->SetOpacity(0.5f);
-  WaitForSwap();
-  EXPECT_TRUE(observer.notified());
+  WaitForDraw();
+  EXPECT_TRUE(observer.started());
 
   // So should setting the opacity back.
   observer.Reset();
   l2->SetOpacity(1.0f);
-  WaitForSwap();
-  EXPECT_TRUE(observer.notified());
+  WaitForDraw();
+  EXPECT_TRUE(observer.started());
 
   // Setting the transform of a layer should alert the observers.
   observer.Reset();
   gfx::Transform transform;
   transform.Translate(200.0, 200.0);
   transform.Rotate(90.0);
   transform.Translate(-200.0, -200.0);
   l2->SetTransform(transform);
-  WaitForSwap();
-  EXPECT_TRUE(observer.notified());
+  WaitForDraw();
+  EXPECT_TRUE(observer.started());
 
   GetCompositor()->RemoveObserver(&observer);
 
   // Opacity changes should no longer alert the removed observer.
   observer.Reset();
   l2->SetOpacity(0.5f);
-  WaitForSwap();
+  WaitForDraw();
 
-  EXPECT_FALSE(observer.notified());
+  EXPECT_FALSE(observer.started());
 }
 
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, ModifyHierarchy) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   //  | +-l21
   //  +-l12
@@ skipping 828 matching lines @@
 
 TEST_F(LayerWithRealCompositorTest, CompositorAnimationObserverTest) {
   std::unique_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
 
   root->SetAnimator(LayerAnimator::CreateImplicitAnimator());
 
   TestCompositorAnimationObserver animation_observer(GetCompositor());
   EXPECT_EQ(0u, animation_observer.animation_step_count());
 
   root->SetOpacity(0.5f);
-  WaitForSwap();
+  WaitForDraw();
   EXPECT_EQ(1u, animation_observer.animation_step_count());
 
   EXPECT_FALSE(animation_observer.shutdown());
   ResetCompositor();
   EXPECT_TRUE(animation_observer.shutdown());
 }
 
 // A simple AnimationMetricsReporter class that remembers smoothness metric
 // when animation completes.
 class TestMetricsReporter : public ui::AnimationMetricsReporter {
@@ skipping 25 matching lines @@
   LayerAnimator* animator = root->GetAnimator();
   std::unique_ptr<ui::LayerAnimationElement> animation_element =
       ui::LayerAnimationElement::CreateColorElement(
           SK_ColorRED, base::TimeDelta::FromMilliseconds(100));
   ui::LayerAnimationSequence* animation_sequence =
       new ui::LayerAnimationSequence(std::move(animation_element));
   TestMetricsReporter reporter;
   animation_sequence->SetAnimationMetricsReporter(&reporter);
   animator->StartAnimation(animation_sequence);
   while (!reporter.report_called())
-    WaitForSwap();
+    WaitForDraw();
   ResetCompositor();
   // Even though most of the time 100% smooth animations are expected, on the
   // test bots this cannot be guaranteed. Therefore simply check that some
   // value was reported.
   EXPECT_GT(reporter.value(), 0);
 }
 
 TEST(LayerDebugInfoTest, LayerNameDoesNotClobber) {
   Layer layer(LAYER_NOT_DRAWN);
   layer.set_name("foo");
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info =
       layer.TakeDebugInfo(nullptr);
   std::string trace_format("bar,");
   debug_info->AppendAsTraceFormat(&trace_format);
   std::string expected("bar,{\"layer_name\":\"foo\"}");
   EXPECT_EQ(expected, trace_format);
 }
 
 }  // namespace ui