Remove "mixin" from BeginFrameSource/Observer base classes.

cc/scheduler/begin_frame_source_unittest.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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 152 matching lines @@
 #ifdef NDEBUG
         nullptr,
 #else
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
 #endif
         -1,
         -1,
         -1);
 
-// BeginFrameObserverMixIn testing ---------------------------------------
-class MockMinimalBeginFrameObserverMixIn : public BeginFrameObserverMixIn {
+// BeginFrameObserverBase testing ---------------------------------------
+class MockMinimalBeginFrameObserverBase : public BeginFrameObserverBase {
  public:
-  MOCK_METHOD1(OnBeginFrameMixInDelegate, bool(const BeginFrameArgs&));
+  MOCK_METHOD1(OnBeginFrameDerivedImpl, bool(const BeginFrameArgs&));
   int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
 };
 
-TEST(BeginFrameObserverMixInTest, OnBeginFrameImplementation) {
+TEST(BeginFrameObserverBaseTest, OnBeginFrameImplementation) {
   using ::testing::Return;
-  MockMinimalBeginFrameObserverMixIn obs;
+  MockMinimalBeginFrameObserverBase obs;
   ::testing::InSequence ordered;  // These calls should be ordered
 
   // Initial conditions
   EXPECT_EQ(BeginFrameArgs(), obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(0, obs.dropped_begin_frame_args());
 
 #ifndef NDEBUG
   EXPECT_DEATH({ obs.OnBeginFrame(BeginFrameArgs()); }, "");
 #endif
 
   BeginFrameArgs args1 =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300);
-  EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args1)).WillOnce(Return(true));
+  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args1)).WillOnce(Return(true));
   obs.OnBeginFrame(args1);
   EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(0, obs.dropped_begin_frame_args());
 
 #ifndef NDEBUG
   EXPECT_DEATH({
                  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
                      BEGINFRAME_FROM_HERE, 50, 200, 300));
                },
                "");
 #endif
 
   // Returning false shouldn't update the LastUsedBeginFrameArgs value.
   BeginFrameArgs args2 =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 200, 300, 400);
-  EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args2)).WillOnce(Return(false));
+  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args2)).WillOnce(Return(false));
   obs.OnBeginFrame(args2);
   EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(1, obs.dropped_begin_frame_args());
 
   BeginFrameArgs args3 =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 150, 300, 400);
-  EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args3)).WillOnce(Return(true));
+  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args3)).WillOnce(Return(true));
   obs.OnBeginFrame(args3);
   EXPECT_EQ(args3, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(1, obs.dropped_begin_frame_args());
 }
 
 // BeginFrameSource testing ----------------------------------------------
-TEST(BeginFrameSourceMixInTest, ObserverManipulation) {
+TEST(BeginFrameSourceBaseTest, ObserverManipulation) {
   MockBeginFrameObserver obs;
   MockBeginFrameObserver otherObs;
   FakeBeginFrameSource source;
 
   source.AddObserver(&obs);
   EXPECT_EQ(&obs, source.GetObserver());
 
 #ifndef NDEBUG
   // Adding an observer when an observer already exists should DCHECK fail.
   EXPECT_DEATH({ source.AddObserver(&otherObs); }, "");
 
   // Removing wrong observer should DCHECK fail.
   EXPECT_DEATH({ source.RemoveObserver(&otherObs); }, "");
 
   // Removing an observer when there is no observer should DCHECK fail.
   EXPECT_DEATH({
                  source.RemoveObserver(&obs);
                  source.RemoveObserver(&obs);
                },
                "");
 #endif
   source.RemoveObserver(&obs);
 
   source.AddObserver(&otherObs);
   EXPECT_EQ(&otherObs, source.GetObserver());
   source.RemoveObserver(&otherObs);
 }
 
-TEST(BeginFrameSourceMixInTest, Observer) {
+TEST(BeginFrameSourceBaseTest, Observer) {
   FakeBeginFrameSource source;
   MockBeginFrameObserver obs;
   source.AddObserver(&obs);
   EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
   EXPECT_BEGIN_FRAME_DROP(obs, 400, 600, 300);
   EXPECT_BEGIN_FRAME_DROP(obs, 450, 650, 300);
   EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
 
   SEND_BEGIN_FRAME_USED(source, 100, 200, 300);
   SEND_BEGIN_FRAME_DROP(source, 400, 600, 300);
   SEND_BEGIN_FRAME_DROP(source, 450, 650, 300);
   SEND_BEGIN_FRAME_USED(source, 700, 900, 300);
 }
 
-TEST(BeginFrameSourceMixInTest, NoObserver) {
+TEST(BeginFrameSourceBaseTest, NoObserver) {
   FakeBeginFrameSource source;
   SEND_BEGIN_FRAME_DROP(source, 100, 200, 300);
 }
 
-TEST(BeginFrameSourceMixInTest, NeedsBeginFrames) {
+TEST(BeginFrameSourceBaseTest, NeedsBeginFrames) {
   FakeBeginFrameSource source;
   EXPECT_FALSE(source.NeedsBeginFrames());
   source.SetNeedsBeginFrames(true);
   EXPECT_TRUE(source.NeedsBeginFrames());
   source.SetNeedsBeginFrames(false);
   EXPECT_FALSE(source.NeedsBeginFrames());
 }
 
-class LoopingBeginFrameObserver : public BeginFrameObserverMixIn {
+class LoopingBeginFrameObserver : public BeginFrameObserverBase {
  public:
   BeginFrameSource* source_;
 
   void AsValueInto(base::trace_event::TracedValue* dict) const override {
     dict->SetString("type", "LoopingBeginFrameObserver");
     dict->BeginDictionary("source");
     source_->AsValueInto(dict);
     dict->EndDictionary();
   }
 
  protected:
-  // BeginFrameObserverMixIn
-  bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override {
+  // BeginFrameObserverBase
+  bool OnBeginFrameDerivedImpl(const BeginFrameArgs& args) override {
     return true;
   }
 };
 
-TEST(BeginFrameSourceMixInTest, DetectAsValueIntoLoop) {
+TEST(BeginFrameSourceBaseTest, DetectAsValueIntoLoop) {
   LoopingBeginFrameObserver obs;
   FakeBeginFrameSource source;
 
   obs.source_ = &source;
   source.AddObserver(&obs);
 
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   source.AsValueInto(state.get());
 }
@@ skipping 454 matching lines @@
   mux_->SetActiveSource(source2_);
   SEND_BEGIN_FRAME_DROP(*source2_, 750, 1050, 300);
   SEND_BEGIN_FRAME_USED(*source2_, 1050, 1250, 300);
 
   mux_->SetActiveSource(source1_);
   SEND_BEGIN_FRAME_DROP(*source2_, 1100, 1400, 300);
 }
 
 }  // namespace
 }  // namespace cc