Standardize usage of virtual/override/final specifiers in sync/.

sync/internal_api/attachments/attachment_service_proxy_unittest.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_service_proxy.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 73 matching lines @@
     base::AutoLock lock(mutex_);
     ++call_count_;
   }
 };
 
 class AttachmentServiceProxyTest : public testing::Test,
                                    public base::NonThreadSafe {
  protected:
   AttachmentServiceProxyTest() {}
 
-  virtual void SetUp() {
+  void SetUp() override {
     CalledOnValidThread();
     stub_thread.reset(new base::Thread("attachment service stub thread"));
     stub_thread->Start();
     stub.reset(new StubAttachmentService);
     proxy.reset(new AttachmentServiceProxy(stub_thread->message_loop_proxy(),
                                            stub->AsWeakPtr()));
 
     callback_get_or_download =
         base::Bind(&AttachmentServiceProxyTest::IncrementGetOrDownload,
                    base::Unretained(this));
     callback_drop = base::Bind(&AttachmentServiceProxyTest::IncrementDrop,
                                base::Unretained(this));
     count_callback_get_or_download = 0;
     count_callback_drop = 0;
   }
 
-  virtual void TearDown()
-      override {
+  void TearDown() override {
     // We must take care to call the stub's destructor on the stub_thread
     // because that's the thread to which its WeakPtrs are bound.
     if (stub) {
       stub_thread->message_loop()->DeleteSoon(FROM_HERE, stub.release());
       WaitForStubThread();
     }
     stub_thread->Stop();
   }
 
   // a GetOrDownloadCallback
@@ skipping 76 matching lines @@
   // Now that the wrapped object has been destroyed, call again and see that we
   // don't crash and the count remains the same.
   proxy->GetOrDownloadAttachments(AttachmentIdList(), callback_get_or_download);
   WaitForStubThread();
   WaitForStubThread();
   loop.RunUntilIdle();
   EXPECT_EQ(1, count_callback_get_or_download);
 }
 
 }  // namespace syncer