Standardize usage of virtual/override/final in cc/

cc/layers/texture_layer_unittest.cc

 // Copyright 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 "cc/layers/texture_layer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 47 matching lines @@
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
   MOCK_METHOD0(StartRateLimiter, void());
   MOCK_METHOD0(StopRateLimiter, void());
 };
 
 class FakeTextureLayerClient : public TextureLayerClient {
  public:
   FakeTextureLayerClient() : mailbox_changed_(true) {}
 
-  virtual bool PrepareTextureMailbox(
+  bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override {
     if (!mailbox_changed_)
       return false;
 
     *mailbox = mailbox_;
     *release_callback = release_callback_.Pass();
     mailbox_changed_ = false;
     return true;
@@ skipping 207 matching lines @@
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
   layer_tree_host_->SetRootLayer(nullptr);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class TestMailboxHolder : public TextureLayer::TextureMailboxHolder {
  public:
   using TextureLayer::TextureMailboxHolder::Create;
 
  protected:
-  virtual ~TestMailboxHolder() {}
+  ~TestMailboxHolder() override {}
 };
 
 class TextureLayerWithMailboxTest : public TextureLayerTest {
  protected:
   virtual void TearDown() {
     Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
     EXPECT_CALL(test_data_.mock_callback_,
                 Release(test_data_.mailbox_name1_,
                         test_data_.sync_point1_,
                         false)).Times(1);
@@ skipping 412 matching lines @@
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerImplWithMailboxThreadedCallback::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     // Case #1: change mailbox before the commit. The old mailbox should be
     // released immediately.
     SetMailbox('2');
     EXPECT_EQ(1, callback_count_);
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() override {
+  void DidCommit() override {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
         // Case #2: change mailbox after the commit (and draw), where the
         // layer draws. The old mailbox should be released during the next
         // commit.
         SetMailbox('3');
         EXPECT_EQ(1, callback_count_);
         break;
       case 2:
@@ skipping 49 matching lines @@
         layer_->SetTextureMailbox(TextureMailbox(), nullptr);
         EXPECT_EQ(5, callback_count_);
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
-  virtual void AfterTest() override {}
+  void AfterTest() override {}
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_;
   int commit_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerImplWithMailboxThreadedCallback);
 
 
 class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
  protected:
   TextureLayerMailboxIsActivatedDuringCommit() : activate_count_(0) {}
 
   static void ReleaseCallback(uint32 sync_point, bool lost_resource) {}
 
   void SetMailbox(char mailbox_char) {
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
     SetMailbox('1');
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
+  void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     ++activate_count_;
   }
 
-  virtual void DidCommit() override {
+  void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The first mailbox has been activated. Set a new mailbox, and
         // expect the next commit to finish *after* it is activated.
         SetMailbox('2');
         break;
       case 2:
         // The second mailbox has been activated. Remove the layer from
         // the tree to cause another commit/activation. The commit should
         // finish *after* the layer is removed from the active tree.
         layer_->RemoveFromParent();
         break;
       case 3:
         EndTest();
         break;
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0: {
         // The activate for the 1st mailbox should have happened before now.
         EXPECT_EQ(1, activate_count_);
         break;
       }
       case 1: {
         // The activate for the 2nd mailbox should have happened before now.
         EXPECT_EQ(2, activate_count_);
         break;
       }
       case 2: {
         // The activate to remove the layer should have happened before now.
         EXPECT_EQ(3, activate_count_);
         break;
       }
       case 3: {
         NOTREACHED();
         break;
       }
     }
   }
 
-
-  virtual void AfterTest() override {}
+  void AfterTest() override {}
 
   int activate_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerMailboxIsActivatedDuringCommit);
 
 class TextureLayerImplWithMailboxTest : public TextureLayerTest {
@@ skipping 194 matching lines @@
   provider->ReceiveReturnsFromParent(returned);
 }
 
 // Checks that TextureLayer::Update does not cause an extra commit when setting
 // the texture mailbox.
 class TextureLayerNoExtraCommitForMailboxTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   // TextureLayerClient implementation.
-  virtual bool PrepareTextureMailbox(
+  bool PrepareTextureMailbox(
       TextureMailbox* texture_mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Once this has been committed, the mailbox will be released.
       *texture_mailbox = TextureMailbox();
       return true;
     }
 
     *texture_mailbox = TextureMailbox(MailboxFromChar('1'), GL_TEXTURE_2D, 0);
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerNoExtraCommitForMailboxTest::MailboxReleased,
                    base::Unretained(this)));
     return true;
   }
 
   void MailboxReleased(uint32 sync_point, bool lost_resource) {
     // Source frame number during callback is the same as the source frame
     // on which it was released.
     EXPECT_EQ(1, layer_tree_host()->source_frame_number());
     EndTest();
   }
 
-  virtual void SetupTree() override {
+  void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
     texture_layer_ = TextureLayer::CreateForMailbox(this);
     texture_layer_->SetBounds(gfx::Size(10, 10));
     texture_layer_->SetIsDrawable(true);
     root->AddChild(texture_layer_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
   }
 
-  virtual void BeginTest() override {
-    PostSetNeedsCommitToMainThread();
-  }
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() override {
+  void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         EXPECT_FALSE(proxy()->MainFrameWillHappenForTesting());
         // Invalidate the texture layer to clear the mailbox before
         // ending the test.
         texture_layer_->SetNeedsDisplay();
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
-  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) override {
+  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     ASSERT_TRUE(result);
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
     if (!delegated_frame_data)
       return;
 
     // Return all resources immediately.
     TransferableResourceArray resources_to_return =
         output_surface()->resources_held_by_parent();
 
     CompositorFrameAck ack;
     for (size_t i = 0; i < resources_to_return.size(); ++i)
       output_surface()->ReturnResource(resources_to_return[i].id, &ack);
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void AfterTest() override {}
+  void AfterTest() override {}
 
  private:
   scoped_refptr<TextureLayer> texture_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerNoExtraCommitForMailboxTest);
 
 // Checks that changing a mailbox in the client for a TextureLayer that's
 // invisible correctly works and uses the new mailbox as soon as the layer
 // becomes visible (and returns the old one).
 class TextureLayerChangeInvisibleMailboxTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   TextureLayerChangeInvisibleMailboxTest()
       : mailbox_changed_(true),
         mailbox_returned_(0),
         prepare_called_(0),
         commit_count_(0) {
     mailbox_ = MakeMailbox('1');
   }
 
   // TextureLayerClient implementation.
-  virtual bool PrepareTextureMailbox(
+  bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override {
     ++prepare_called_;
     if (!mailbox_changed_)
       return false;
     *mailbox = mailbox_;
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerChangeInvisibleMailboxTest::MailboxReleased,
                    base::Unretained(this)));
     return true;
   }
 
   TextureMailbox MakeMailbox(char name) {
     return TextureMailbox(MailboxFromChar(name), GL_TEXTURE_2D, 0);
   }
 
   void MailboxReleased(uint32 sync_point, bool lost_resource) {
     ++mailbox_returned_;
   }
 
-  virtual void SetupTree() override {
+  void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
     solid_layer_ = SolidColorLayer::Create();
     solid_layer_->SetBounds(gfx::Size(10, 10));
     solid_layer_->SetIsDrawable(true);
     solid_layer_->SetBackgroundColor(SK_ColorWHITE);
     root->AddChild(solid_layer_);
 
     parent_layer_ = Layer::Create();
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root->AddChild(parent_layer_);
 
     texture_layer_ = TextureLayer::CreateForMailbox(this);
     texture_layer_->SetBounds(gfx::Size(10, 10));
     texture_layer_->SetIsDrawable(true);
     parent_layer_->AddChild(texture_layer_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
   }
 
-  virtual void BeginTest() override {
-    PostSetNeedsCommitToMainThread();
-  }
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() override {
+  void DidCommitAndDrawFrame() override {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
         // We should have updated the layer, committing the texture.
         EXPECT_EQ(1, prepare_called_);
         // Make layer invisible.
         parent_layer_->SetOpacity(0.f);
         break;
       case 2:
         // Layer shouldn't have been updated.
@@ skipping 23 matching lines @@
       case 5:
         EXPECT_EQ(2, mailbox_returned_);
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
-  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) override {
+  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     ASSERT_TRUE(result);
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
     if (!delegated_frame_data)
       return;
 
     // Return all resources immediately.
     TransferableResourceArray resources_to_return =
         output_surface()->resources_held_by_parent();
 
     CompositorFrameAck ack;
     for (size_t i = 0; i < resources_to_return.size(); ++i)
       output_surface()->ReturnResource(resources_to_return[i].id, &ack);
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void AfterTest() override {}
+  void AfterTest() override {}
 
  private:
   scoped_refptr<SolidColorLayer> solid_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<TextureLayer> texture_layer_;
 
   // Used on the main thread.
   bool mailbox_changed_;
   TextureMailbox mailbox_;
   int mailbox_returned_;
   int prepare_called_;
   int commit_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerChangeInvisibleMailboxTest);
 
 // Test that TextureLayerImpl::ReleaseResources can be called which releases
 // the mailbox back to TextureLayerClient.
 class TextureLayerReleaseResourcesBase
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   // TextureLayerClient implementation.
-  virtual bool PrepareTextureMailbox(
+  bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override {
     *mailbox = TextureMailbox(MailboxFromChar('1'), GL_TEXTURE_2D, 0);
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerReleaseResourcesBase::MailboxReleased,
                    base::Unretained(this)));
     return true;
   }
 
   void MailboxReleased(unsigned sync_point, bool lost_resource) {
     mailbox_released_ = true;
   }
 
-  virtual void SetupTree() override {
+  void SetupTree() override {
     LayerTreeTest::SetupTree();
 
     scoped_refptr<TextureLayer> texture_layer =
         TextureLayer::CreateForMailbox(this);
     texture_layer->SetBounds(gfx::Size(10, 10));
     texture_layer->SetIsDrawable(true);
 
     layer_tree_host()->root_layer()->AddChild(texture_layer);
   }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     mailbox_released_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() override {
-    EndTest();
-  }
+  void DidCommitAndDrawFrame() override { EndTest(); }
 
-  virtual void AfterTest() override {
-    EXPECT_TRUE(mailbox_released_);
-  }
+  void AfterTest() override { EXPECT_TRUE(mailbox_released_); }
 
  private:
   bool mailbox_released_;
 };
 
 class TextureLayerReleaseResourcesAfterCommit
     : public TextureLayerReleaseResourcesBase {
  public:
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeImpl* tree = nullptr;
     if (host_impl->settings().impl_side_painting)
       tree = host_impl->pending_tree();
     else
       tree = host_impl->active_tree();
     tree->root_layer()->children()[0]->ReleaseResources();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerReleaseResourcesAfterCommit);
 
 class TextureLayerReleaseResourcesAfterActivate
     : public TextureLayerReleaseResourcesBase {
  public:
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+  void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->active_tree()->root_layer()->children()[0]->ReleaseResources();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerReleaseResourcesAfterActivate);
 
 class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
  public:
   void ReleaseCallback(uint32 sync_point, bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
     EndTest();
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxMainThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
-  virtual void SetupTree() override {
+  void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
   }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     callback_count_ = 0;
 
     // Set the mailbox on the main thread.
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() override {
+  void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Delete the TextureLayer on the main thread while the mailbox is in
         // the impl tree.
         layer_->RemoveFromParent();
         layer_ = nullptr;
         break;
     }
   }
 
-  virtual void AfterTest() override {
-    EXPECT_EQ(1, callback_count_);
-  }
+  void AfterTest() override { EXPECT_EQ(1, callback_count_); }
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxMainThreadDeleted);
@@ skipping 11 matching lines @@
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxImplThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
-  virtual void SetupTree() override {
+  void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
   }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     callback_count_ = 0;
 
     // Set the mailbox on the main thread.
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() override {
+  void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Remove the TextureLayer on the main thread while the mailbox is in
         // the impl tree, but don't delete the TextureLayer until after the impl
         // tree side is deleted.
         layer_->RemoveFromParent();
         break;
       case 2:
         layer_ = nullptr;
         break;
     }
   }
 
-  virtual void AfterTest() override {
-    EXPECT_EQ(1, callback_count_);
-  }
+  void AfterTest() override { EXPECT_EQ(1, callback_count_); }
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc