diff options
| author | mostynb <mostynb@opera.com> | 2014-10-07 10:59:11 -0700 |
|---|---|---|
| committer | Commit bot <commit-bot@chromium.org> | 2014-10-07 17:59:25 +0000 |
| commit | 9e096de10e6fdcafde67df469ed9a6b8b156dfb1 (patch) | |
| tree | 301e744a7e3e865e32a6fd0a779c115e926b7fd6 /base | |
| parent | 35d1d3a0d525595304fc8333373ddb660bd649cc (diff) | |
| download | chromium_src-9e096de10e6fdcafde67df469ed9a6b8b156dfb1.zip chromium_src-9e096de10e6fdcafde67df469ed9a6b8b156dfb1.tar.gz chromium_src-9e096de10e6fdcafde67df469ed9a6b8b156dfb1.tar.bz2 | |
replace OVERRIDE and FINAL with override and final in base/
BUG=417463
Review URL: https://codereview.chromium.org/611153004
Cr-Commit-Position: refs/heads/master@{#298520}
Diffstat (limited to 'base')
152 files changed, 637 insertions, 596 deletions
diff --git a/base/PRESUBMIT.py b/base/PRESUBMIT.py index 732ac27..758a790 100644 --- a/base/PRESUBMIT.py +++ b/base/PRESUBMIT.py @@ -8,6 +8,10 @@ See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts for more details on the presubmit API built into gcl. """ +import re + +BASE_SOURCE_FILES=(r'^base/.*\.(cc|h|mm)$',) + def _CheckNoInterfacesInBase(input_api, output_api): """Checks to make sure no files in libbase.a have |@interface|.""" pattern = input_api.re.compile(r'^\s*@interface', input_api.re.MULTILINE) @@ -36,8 +40,45 @@ def _CommonChecks(input_api, output_api): results.extend(_CheckNoInterfacesInBase(input_api, output_api)) return results +def _CheckOverrideFinal(input_api, output_api, + whitelist=BASE_SOURCE_FILES, blacklist=None): + """Make sure new lines of code don't use the OVERRIDE or FINAL macros.""" + + # TODO(mostynb): remove this check once the macros are removed + # from base/compiler_specific.h. + + errors = [] + + source_file_filter = lambda x: input_api.FilterSourceFile( + x, white_list=BASE_SOURCE_FILES, black_list=None) + + override_files = [] + final_files = [] + + for f in input_api.AffectedSourceFiles(source_file_filter): + contents = input_api.ReadFile(f, 'rb') + + # "override" and "final" should be used instead of OVERRIDE/FINAL now. + if re.search(r"\bOVERRIDE\b", contents): + override_files.append(f.LocalPath()) + + if re.search(r"\bFINAL\b", contents): + final_files.append(f.LocalPath()) + + if override_files: + return [output_api.PresubmitError( + 'These files use OVERRIDE instead of using override:', + items=override_files)] + if final_files: + return [output_api.PresubmitError( + 'These files use FINAL instead of using final:', + items=final_files)] + + return [] + def CheckChangeOnUpload(input_api, output_api): results = [] + results.extend(_CheckOverrideFinal(input_api, output_api)) results.extend(_CommonChecks(input_api, output_api)) return results diff --git a/base/android/trace_event_binding.cc b/base/android/trace_event_binding.cc index e261411..216ba7b 100644 --- a/base/android/trace_event_binding.cc +++ b/base/android/trace_event_binding.cc @@ -57,11 +57,11 @@ class TraceEventDataConverter { class TraceEnabledObserver : public debug::TraceLog::EnabledStateObserver { public: - virtual void OnTraceLogEnabled() OVERRIDE { + virtual void OnTraceLogEnabled() override { JNIEnv* env = base::android::AttachCurrentThread(); base::android::Java_TraceEvent_setEnabled(env, true); } - virtual void OnTraceLogDisabled() OVERRIDE { + virtual void OnTraceLogDisabled() override { JNIEnv* env = base::android::AttachCurrentThread(); base::android::Java_TraceEvent_setEnabled(env, false); } diff --git a/base/async_socket_io_handler.h b/base/async_socket_io_handler.h index 2f4b13d..71ca5f4 100644 --- a/base/async_socket_io_handler.h +++ b/base/async_socket_io_handler.h @@ -78,11 +78,11 @@ class BASE_EXPORT AsyncSocketIoHandler // Implementation of IOHandler on Windows. virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context, DWORD bytes_transfered, - DWORD error) OVERRIDE; + DWORD error) override; #elif defined(OS_POSIX) // Implementation of base::MessageLoopForIO::Watcher. - virtual void OnFileCanWriteWithoutBlocking(int socket) OVERRIDE {} - virtual void OnFileCanReadWithoutBlocking(int socket) OVERRIDE; + virtual void OnFileCanWriteWithoutBlocking(int socket) override {} + virtual void OnFileCanReadWithoutBlocking(int socket) override; void EnsureWatchingSocket(); #endif diff --git a/base/bind_unittest.cc b/base/bind_unittest.cc index e1f15cb..ce1af1b 100644 --- a/base/bind_unittest.cc +++ b/base/bind_unittest.cc @@ -66,7 +66,7 @@ class Parent { class Child : public Parent { public: - virtual void VirtualSet() OVERRIDE { value = kChildValue; } + virtual void VirtualSet() override { value = kChildValue; } void NonVirtualSet() { value = kChildValue; } }; @@ -78,7 +78,7 @@ class NoRefParent { }; class NoRefChild : public NoRefParent { - virtual void VirtualSet() OVERRIDE { value = kChildValue; } + virtual void VirtualSet() override { value = kChildValue; } void NonVirtualSet() { value = kChildValue; } }; diff --git a/base/debug/stack_trace_posix.cc b/base/debug/stack_trace_posix.cc index 9e477cf..ae40d7c 100644 --- a/base/debug/stack_trace_posix.cc +++ b/base/debug/stack_trace_posix.cc @@ -402,7 +402,7 @@ class PrintBacktraceOutputHandler : public BacktraceOutputHandler { public: PrintBacktraceOutputHandler() {} - virtual void HandleOutput(const char* output) OVERRIDE { + virtual void HandleOutput(const char* output) override { // NOTE: This code MUST be async-signal safe (it's used by in-process // stack dumping signal handler). NO malloc or stdio is allowed here. PrintToStderr(output); @@ -417,7 +417,7 @@ class StreamBacktraceOutputHandler : public BacktraceOutputHandler { explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) { } - virtual void HandleOutput(const char* output) OVERRIDE { + virtual void HandleOutput(const char* output) override { (*os_) << output; } diff --git a/base/debug/trace_event.h b/base/debug/trace_event.h index db78f74..62a9b1f 100644 --- a/base/debug/trace_event.h +++ b/base/debug/trace_event.h @@ -144,7 +144,7 @@ // class MyData : public base::debug::ConvertableToTraceFormat { // public: // MyData() {} -// virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE { +// virtual void AppendAsTraceFormat(std::string* out) const override { // out->append("{\"foo\":1}"); // } // private: diff --git a/base/debug/trace_event_argument.h b/base/debug/trace_event_argument.h index 9d35358..7aa7c87 100644 --- a/base/debug/trace_event_argument.h +++ b/base/debug/trace_event_argument.h @@ -40,7 +40,7 @@ class BASE_EXPORT TracedValue : public ConvertableToTraceFormat { void BeginArray(); void BeginDictionary(); - virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE; + virtual void AppendAsTraceFormat(std::string* out) const override; private: virtual ~TracedValue(); diff --git a/base/debug/trace_event_impl.cc b/base/debug/trace_event_impl.cc index 9110bf2..0607a19 100644 --- a/base/debug/trace_event_impl.cc +++ b/base/debug/trace_event_impl.cc @@ -140,7 +140,7 @@ class TraceBufferRingBuffer : public TraceBuffer { recyclable_chunks_queue_[i] = i; } - virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE { + virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override { // Because the number of threads is much less than the number of chunks, // the queue should never be empty. DCHECK(!QueueIsEmpty()); @@ -163,7 +163,7 @@ class TraceBufferRingBuffer : public TraceBuffer { } virtual void ReturnChunk(size_t index, - scoped_ptr<TraceBufferChunk> chunk) OVERRIDE { + scoped_ptr<TraceBufferChunk> chunk) override { // When this method is called, the queue should not be full because it // can contain all chunks including the one to be returned. DCHECK(!QueueIsFull()); @@ -175,20 +175,20 @@ class TraceBufferRingBuffer : public TraceBuffer { queue_tail_ = NextQueueIndex(queue_tail_); } - virtual bool IsFull() const OVERRIDE { + virtual bool IsFull() const override { return false; } - virtual size_t Size() const OVERRIDE { + virtual size_t Size() const override { // This is approximate because not all of the chunks are full. return chunks_.size() * kTraceBufferChunkSize; } - virtual size_t Capacity() const OVERRIDE { + virtual size_t Capacity() const override { return max_chunks_ * kTraceBufferChunkSize; } - virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE { + virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override { if (handle.chunk_index >= chunks_.size()) return NULL; TraceBufferChunk* chunk = chunks_[handle.chunk_index]; @@ -197,7 +197,7 @@ class TraceBufferRingBuffer : public TraceBuffer { return chunk->GetEventAt(handle.event_index); } - virtual const TraceBufferChunk* NextChunk() OVERRIDE { + virtual const TraceBufferChunk* NextChunk() override { if (chunks_.empty()) return NULL; @@ -212,7 +212,7 @@ class TraceBufferRingBuffer : public TraceBuffer { return NULL; } - virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE { + virtual scoped_ptr<TraceBuffer> CloneForIteration() const override { scoped_ptr<ClonedTraceBuffer> cloned_buffer(new ClonedTraceBuffer()); for (size_t queue_index = queue_head_; queue_index != queue_tail_; queue_index = NextQueueIndex(queue_index)) { @@ -231,26 +231,26 @@ class TraceBufferRingBuffer : public TraceBuffer { ClonedTraceBuffer() : current_iteration_index_(0) {} // The only implemented method. - virtual const TraceBufferChunk* NextChunk() OVERRIDE { + virtual const TraceBufferChunk* NextChunk() override { return current_iteration_index_ < chunks_.size() ? chunks_[current_iteration_index_++] : NULL; } - virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE { + virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override { NOTIMPLEMENTED(); return scoped_ptr<TraceBufferChunk>(); } virtual void ReturnChunk(size_t index, - scoped_ptr<TraceBufferChunk>) OVERRIDE { + scoped_ptr<TraceBufferChunk>) override { NOTIMPLEMENTED(); } - virtual bool IsFull() const OVERRIDE { return false; } - virtual size_t Size() const OVERRIDE { return 0; } - virtual size_t Capacity() const OVERRIDE { return 0; } - virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE { + virtual bool IsFull() const override { return false; } + virtual size_t Size() const override { return 0; } + virtual size_t Capacity() const override { return 0; } + virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override { return NULL; } - virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE { + virtual scoped_ptr<TraceBuffer> CloneForIteration() const override { NOTIMPLEMENTED(); return scoped_ptr<TraceBuffer>(); } @@ -306,7 +306,7 @@ class TraceBufferVector : public TraceBuffer { chunks_.reserve(max_chunks_); } - virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) OVERRIDE { + virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override { // This function may be called when adding normal events or indirectly from // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we // have to add the metadata events and flush thread-local buffers even if @@ -320,7 +320,7 @@ class TraceBufferVector : public TraceBuffer { } virtual void ReturnChunk(size_t index, - scoped_ptr<TraceBufferChunk> chunk) OVERRIDE { + scoped_ptr<TraceBufferChunk> chunk) override { DCHECK_GT(in_flight_chunk_count_, 0u); DCHECK_LT(index, chunks_.size()); DCHECK(!chunks_[index]); @@ -328,20 +328,20 @@ class TraceBufferVector : public TraceBuffer { chunks_[index] = chunk.release(); } - virtual bool IsFull() const OVERRIDE { + virtual bool IsFull() const override { return chunks_.size() >= max_chunks_; } - virtual size_t Size() const OVERRIDE { + virtual size_t Size() const override { // This is approximate because not all of the chunks are full. return chunks_.size() * kTraceBufferChunkSize; } - virtual size_t Capacity() const OVERRIDE { + virtual size_t Capacity() const override { return max_chunks_ * kTraceBufferChunkSize; } - virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) OVERRIDE { + virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) override { if (handle.chunk_index >= chunks_.size()) return NULL; TraceBufferChunk* chunk = chunks_[handle.chunk_index]; @@ -350,7 +350,7 @@ class TraceBufferVector : public TraceBuffer { return chunk->GetEventAt(handle.event_index); } - virtual const TraceBufferChunk* NextChunk() OVERRIDE { + virtual const TraceBufferChunk* NextChunk() override { while (current_iteration_index_ < chunks_.size()) { // Skip in-flight chunks. const TraceBufferChunk* chunk = chunks_[current_iteration_index_++]; @@ -360,7 +360,7 @@ class TraceBufferVector : public TraceBuffer { return NULL; } - virtual scoped_ptr<TraceBuffer> CloneForIteration() const OVERRIDE { + virtual scoped_ptr<TraceBuffer> CloneForIteration() const override { NOTIMPLEMENTED(); return scoped_ptr<TraceBuffer>(); } @@ -869,7 +869,7 @@ class TraceSamplingThread : public PlatformThread::Delegate { virtual ~TraceSamplingThread(); // Implementation of PlatformThread::Delegate: - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; static void DefaultSamplingCallback(TraceBucketData* bucekt_data); @@ -1066,7 +1066,7 @@ class TraceLog::ThreadLocalEventBuffer private: // MessageLoop::DestructionObserver - virtual void WillDestroyCurrentMessageLoop() OVERRIDE; + virtual void WillDestroyCurrentMessageLoop() override; void FlushWhileLocked(); diff --git a/base/debug/trace_event_memory.cc b/base/debug/trace_event_memory.cc index 3c46827..5cb0908 100644 --- a/base/debug/trace_event_memory.cc +++ b/base/debug/trace_event_memory.cc @@ -33,7 +33,7 @@ class MemoryDumpHolder : public base::debug::ConvertableToTraceFormat { explicit MemoryDumpHolder(char* dump) : dump_(dump) {} // base::debug::ConvertableToTraceFormat overrides: - virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE { + virtual void AppendAsTraceFormat(std::string* out) const override { AppendHeapProfileAsTraceFormat(dump_, out); } diff --git a/base/debug/trace_event_memory.h b/base/debug/trace_event_memory.h index df2e663..4caeef4 100644 --- a/base/debug/trace_event_memory.h +++ b/base/debug/trace_event_memory.h @@ -47,8 +47,8 @@ class BASE_EXPORT TraceMemoryController virtual ~TraceMemoryController(); // base::debug::TraceLog::EnabledStateChangedObserver overrides: - virtual void OnTraceLogEnabled() OVERRIDE; - virtual void OnTraceLogDisabled() OVERRIDE; + virtual void OnTraceLogEnabled() override; + virtual void OnTraceLogDisabled() override; // Starts heap memory profiling. void StartProfiling(); diff --git a/base/debug/trace_event_synthetic_delay.cc b/base/debug/trace_event_synthetic_delay.cc index 868a777..efb797a 100644 --- a/base/debug/trace_event_synthetic_delay.cc +++ b/base/debug/trace_event_synthetic_delay.cc @@ -23,7 +23,7 @@ class TraceEventSyntheticDelayRegistry : public TraceEventSyntheticDelayClock { void ResetAllDelays(); // TraceEventSyntheticDelayClock implementation. - virtual base::TimeTicks Now() OVERRIDE; + virtual base::TimeTicks Now() override; private: TraceEventSyntheticDelayRegistry(); diff --git a/base/debug/trace_event_synthetic_delay_unittest.cc b/base/debug/trace_event_synthetic_delay_unittest.cc index a418eed..124706f 100644 --- a/base/debug/trace_event_synthetic_delay_unittest.cc +++ b/base/debug/trace_event_synthetic_delay_unittest.cc @@ -26,7 +26,7 @@ class TraceEventSyntheticDelayTest : public testing::Test, } // TraceEventSyntheticDelayClock implementation. - virtual base::TimeTicks Now() OVERRIDE { + virtual base::TimeTicks Now() override { AdvanceTime(base::TimeDelta::FromMilliseconds(kShortDurationMs / 10)); return now_; } diff --git a/base/debug/trace_event_system_stats_monitor.cc b/base/debug/trace_event_system_stats_monitor.cc index a712838..b2bf2ae8 100644 --- a/base/debug/trace_event_system_stats_monitor.cc +++ b/base/debug/trace_event_system_stats_monitor.cc @@ -31,7 +31,7 @@ class SystemStatsHolder : public base::debug::ConvertableToTraceFormat { void GetSystemProfilingStats(); // base::debug::ConvertableToTraceFormat overrides: - virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE { + virtual void AppendAsTraceFormat(std::string* out) const override { AppendSystemProfileAsTraceFormat(system_stats_, out); } diff --git a/base/debug/trace_event_system_stats_monitor.h b/base/debug/trace_event_system_stats_monitor.h index 1a8b328..f676fce 100644 --- a/base/debug/trace_event_system_stats_monitor.h +++ b/base/debug/trace_event_system_stats_monitor.h @@ -36,8 +36,8 @@ class BASE_EXPORT TraceEventSystemStatsMonitor virtual ~TraceEventSystemStatsMonitor(); // base::debug::TraceLog::EnabledStateChangedObserver overrides: - virtual void OnTraceLogEnabled() OVERRIDE; - virtual void OnTraceLogDisabled() OVERRIDE; + virtual void OnTraceLogEnabled() override; + virtual void OnTraceLogDisabled() override; // Retrieves system profiling at the current time. void DumpSystemStats(); diff --git a/base/debug/trace_event_unittest.cc b/base/debug/trace_event_unittest.cc index 581906b..90be070 100644 --- a/base/debug/trace_event_unittest.cc +++ b/base/debug/trace_event_unittest.cc @@ -125,7 +125,7 @@ class TraceEventTestFixture : public testing::Test { base::Unretained(flush_complete_event))); } - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { const char* name = PlatformThread::GetName(); old_thread_name_ = name ? strdup(name) : NULL; @@ -136,7 +136,7 @@ class TraceEventTestFixture : public testing::Test { trace_buffer_.SetOutputCallback(json_output_.GetCallback()); event_watch_notification_ = 0; } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { if (TraceLog::GetInstance()) EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled()); PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : ""); @@ -996,11 +996,11 @@ class AfterStateChangeEnabledStateObserver virtual ~AfterStateChangeEnabledStateObserver() {} // TraceLog::EnabledStateObserver overrides: - virtual void OnTraceLogEnabled() OVERRIDE { + virtual void OnTraceLogEnabled() override { EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled()); } - virtual void OnTraceLogDisabled() OVERRIDE { + virtual void OnTraceLogDisabled() override { EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled()); } }; @@ -1029,9 +1029,9 @@ class SelfRemovingEnabledStateObserver virtual ~SelfRemovingEnabledStateObserver() {} // TraceLog::EnabledStateObserver overrides: - virtual void OnTraceLogEnabled() OVERRIDE {} + virtual void OnTraceLogEnabled() override {} - virtual void OnTraceLogDisabled() OVERRIDE { + virtual void OnTraceLogDisabled() override { TraceLog::GetInstance()->RemoveEnabledStateObserver(this); } }; @@ -1919,7 +1919,7 @@ class MyData : public ConvertableToTraceFormat { public: MyData() {} - virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE { + virtual void AppendAsTraceFormat(std::string* out) const override { out->append("{\"foo\":1}"); } @@ -2203,12 +2203,12 @@ TEST_F(TraceEventTestFixture, PrimitiveArgs) { class TraceEventCallbackTest : public TraceEventTestFixture { public: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { TraceEventTestFixture::SetUp(); ASSERT_EQ(NULL, s_instance); s_instance = this; } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { TraceLog::GetInstance()->SetDisabled(); ASSERT_TRUE(!!s_instance); s_instance = NULL; diff --git a/base/deferred_sequenced_task_runner.h b/base/deferred_sequenced_task_runner.h index 00ab050..3220ac1 100644 --- a/base/deferred_sequenced_task_runner.h +++ b/base/deferred_sequenced_task_runner.h @@ -29,14 +29,14 @@ class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner { // TaskRunner implementation virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; // SequencedTaskRunner implementation virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; + TimeDelta delay) override; // Start the execution - posts all queued tasks to the target executor. The // deferred tasks are posted with their initial delay, meaning that the task diff --git a/base/environment.cc b/base/environment.cc index c547730..94a766c 100644 --- a/base/environment.cc +++ b/base/environment.cc @@ -23,7 +23,7 @@ namespace { class EnvironmentImpl : public base::Environment { public: virtual bool GetVar(const char* variable_name, - std::string* result) OVERRIDE { + std::string* result) override { if (GetVarImpl(variable_name, result)) return true; @@ -43,11 +43,11 @@ class EnvironmentImpl : public base::Environment { } virtual bool SetVar(const char* variable_name, - const std::string& new_value) OVERRIDE { + const std::string& new_value) override { return SetVarImpl(variable_name, new_value); } - virtual bool UnSetVar(const char* variable_name) OVERRIDE { + virtual bool UnSetVar(const char* variable_name) override { return UnSetVarImpl(variable_name); } diff --git a/base/file_version_info_mac.h b/base/file_version_info_mac.h index f0edb3a..50a04eb 100644 --- a/base/file_version_info_mac.h +++ b/base/file_version_info_mac.h @@ -23,22 +23,22 @@ class FileVersionInfoMac : public FileVersionInfo { // Accessors to the different version properties. // Returns an empty string if the property is not found. - virtual base::string16 company_name() OVERRIDE; - virtual base::string16 company_short_name() OVERRIDE; - virtual base::string16 product_name() OVERRIDE; - virtual base::string16 product_short_name() OVERRIDE; - virtual base::string16 internal_name() OVERRIDE; - virtual base::string16 product_version() OVERRIDE; - virtual base::string16 private_build() OVERRIDE; - virtual base::string16 special_build() OVERRIDE; - virtual base::string16 comments() OVERRIDE; - virtual base::string16 original_filename() OVERRIDE; - virtual base::string16 file_description() OVERRIDE; - virtual base::string16 file_version() OVERRIDE; - virtual base::string16 legal_copyright() OVERRIDE; - virtual base::string16 legal_trademarks() OVERRIDE; - virtual base::string16 last_change() OVERRIDE; - virtual bool is_official_build() OVERRIDE; + virtual base::string16 company_name() override; + virtual base::string16 company_short_name() override; + virtual base::string16 product_name() override; + virtual base::string16 product_short_name() override; + virtual base::string16 internal_name() override; + virtual base::string16 product_version() override; + virtual base::string16 private_build() override; + virtual base::string16 special_build() override; + virtual base::string16 comments() override; + virtual base::string16 original_filename() override; + virtual base::string16 file_description() override; + virtual base::string16 file_version() override; + virtual base::string16 legal_copyright() override; + virtual base::string16 legal_trademarks() override; + virtual base::string16 last_change() override; + virtual bool is_official_build() override; private: // Returns a base::string16 value for a property name. diff --git a/base/file_version_info_win.h b/base/file_version_info_win.h index 34bc675..0e0f271 100644 --- a/base/file_version_info_win.h +++ b/base/file_version_info_win.h @@ -22,22 +22,22 @@ class FileVersionInfoWin : public FileVersionInfo { // Accessors to the different version properties. // Returns an empty string if the property is not found. - virtual base::string16 company_name() OVERRIDE; - virtual base::string16 company_short_name() OVERRIDE; - virtual base::string16 product_name() OVERRIDE; - virtual base::string16 product_short_name() OVERRIDE; - virtual base::string16 internal_name() OVERRIDE; - virtual base::string16 product_version() OVERRIDE; - virtual base::string16 private_build() OVERRIDE; - virtual base::string16 special_build() OVERRIDE; - virtual base::string16 comments() OVERRIDE; - virtual base::string16 original_filename() OVERRIDE; - virtual base::string16 file_description() OVERRIDE; - virtual base::string16 file_version() OVERRIDE; - virtual base::string16 legal_copyright() OVERRIDE; - virtual base::string16 legal_trademarks() OVERRIDE; - virtual base::string16 last_change() OVERRIDE; - virtual bool is_official_build() OVERRIDE; + virtual base::string16 company_name() override; + virtual base::string16 company_short_name() override; + virtual base::string16 product_name() override; + virtual base::string16 product_short_name() override; + virtual base::string16 internal_name() override; + virtual base::string16 product_version() override; + virtual base::string16 private_build() override; + virtual base::string16 special_build() override; + virtual base::string16 comments() override; + virtual base::string16 original_filename() override; + virtual base::string16 file_description() override; + virtual base::string16 file_version() override; + virtual base::string16 legal_copyright() override; + virtual base::string16 legal_trademarks() override; + virtual base::string16 last_change() override; + virtual bool is_official_build() override; // Lets you access other properties not covered above. BASE_EXPORT bool GetValue(const wchar_t* name, std::wstring* value); diff --git a/base/files/file_path_unittest.cc b/base/files/file_path_unittest.cc index 8b6f3a8..906d8df 100644 --- a/base/files/file_path_unittest.cc +++ b/base/files/file_path_unittest.cc @@ -50,10 +50,10 @@ struct UTF8TestData { // to be a PlatformTest class FilePathTest : public PlatformTest { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { PlatformTest::SetUp(); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { PlatformTest::TearDown(); } }; diff --git a/base/files/file_path_watcher_browsertest.cc b/base/files/file_path_watcher_browsertest.cc index 5cf75fc..f6d6d33 100644 --- a/base/files/file_path_watcher_browsertest.cc +++ b/base/files/file_path_watcher_browsertest.cc @@ -113,7 +113,7 @@ class TestDelegate : public TestDelegateBase { } virtual ~TestDelegate() {} - virtual void OnFileChanged(const FilePath& path, bool error) OVERRIDE { + virtual void OnFileChanged(const FilePath& path, bool error) override { if (error) ADD_FAILURE() << "Error " << path.value(); else @@ -146,7 +146,7 @@ class FilePathWatcherTest : public testing::Test { virtual ~FilePathWatcherTest() {} protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { // Create a separate file thread in order to test proper thread usage. base::Thread::Options options(MessageLoop::TYPE_IO, 0); ASSERT_TRUE(file_thread_.StartWithOptions(options)); @@ -154,7 +154,7 @@ class FilePathWatcherTest : public testing::Test { collector_ = new NotificationCollector(); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { RunLoop().RunUntilIdle(); } @@ -274,7 +274,7 @@ class Deleter : public TestDelegateBase { } virtual ~Deleter() {} - virtual void OnFileChanged(const FilePath&, bool) OVERRIDE { + virtual void OnFileChanged(const FilePath&, bool) override { watcher_.reset(); loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); } diff --git a/base/files/file_path_watcher_fsevents.h b/base/files/file_path_watcher_fsevents.h index 5640b4d..d2fb8da 100644 --- a/base/files/file_path_watcher_fsevents.h +++ b/base/files/file_path_watcher_fsevents.h @@ -38,8 +38,8 @@ class FilePathWatcherFSEvents : public FilePathWatcher::PlatformDelegate { // FilePathWatcher::PlatformDelegate overrides. virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE; - virtual void Cancel() OVERRIDE; + const FilePathWatcher::Callback& callback) override; + virtual void Cancel() override; private: virtual ~FilePathWatcherFSEvents(); @@ -51,7 +51,7 @@ class FilePathWatcherFSEvents : public FilePathWatcher::PlatformDelegate { void StartEventStream(FSEventStreamEventId start_event); // Cleans up and stops the event stream. - virtual void CancelOnMessageLoopThread() OVERRIDE; + virtual void CancelOnMessageLoopThread() override; // Callback to notify upon changes. FilePathWatcher::Callback callback_; diff --git a/base/files/file_path_watcher_kqueue.h b/base/files/file_path_watcher_kqueue.h index 703fda6..aa13af3 100644 --- a/base/files/file_path_watcher_kqueue.h +++ b/base/files/file_path_watcher_kqueue.h @@ -33,17 +33,17 @@ class FilePathWatcherKQueue : public FilePathWatcher::PlatformDelegate, FilePathWatcherKQueue(); // MessageLoopForIO::Watcher overrides. - virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE; - virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE; + virtual void OnFileCanReadWithoutBlocking(int fd) override; + virtual void OnFileCanWriteWithoutBlocking(int fd) override; // MessageLoop::DestructionObserver overrides. - virtual void WillDestroyCurrentMessageLoop() OVERRIDE; + virtual void WillDestroyCurrentMessageLoop() override; // FilePathWatcher::PlatformDelegate overrides. virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE; - virtual void Cancel() OVERRIDE; + const FilePathWatcher::Callback& callback) override; + virtual void Cancel() override; protected: virtual ~FilePathWatcherKQueue(); @@ -60,7 +60,7 @@ class FilePathWatcherKQueue : public FilePathWatcher::PlatformDelegate, typedef std::vector<struct kevent> EventVector; // Can only be called on |io_message_loop_|'s thread. - virtual void CancelOnMessageLoopThread() OVERRIDE; + virtual void CancelOnMessageLoopThread() override; // Returns true if the kevent values are error free. bool AreKeventValuesValid(struct kevent* kevents, int count); diff --git a/base/files/file_path_watcher_linux.cc b/base/files/file_path_watcher_linux.cc index d5d664e..fb5ba62 100644 --- a/base/files/file_path_watcher_linux.cc +++ b/base/files/file_path_watcher_linux.cc @@ -112,18 +112,18 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate, // Returns true if watch for |path| has been added successfully. virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE; + const FilePathWatcher::Callback& callback) override; // Cancel the watch. This unregisters the instance with InotifyReader. - virtual void Cancel() OVERRIDE; + virtual void Cancel() override; // Cleans up and stops observing the message_loop() thread. - virtual void CancelOnMessageLoopThread() OVERRIDE; + virtual void CancelOnMessageLoopThread() override; // Deletion of the FilePathWatcher will call Cancel() to dispose of this // object in the right thread. This also observes destruction of the required // cleanup thread, in case it quits before Cancel() is called. - virtual void WillDestroyCurrentMessageLoop() OVERRIDE; + virtual void WillDestroyCurrentMessageLoop() override; // Inotify watches are installed for all directory components of |target_|. A // WatchEntry instance holds the watch descriptor for a component and the diff --git a/base/files/file_path_watcher_mac.cc b/base/files/file_path_watcher_mac.cc index b21ba1d..58f78bd 100644 --- a/base/files/file_path_watcher_mac.cc +++ b/base/files/file_path_watcher_mac.cc @@ -17,7 +17,7 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate { public: virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE { + const FilePathWatcher::Callback& callback) override { // Use kqueue for non-recursive watches and FSEvents for recursive ones. DCHECK(!impl_.get()); if (recursive) { @@ -33,13 +33,13 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate { return impl_->Watch(path, recursive, callback); } - virtual void Cancel() OVERRIDE { + virtual void Cancel() override { if (impl_.get()) impl_->Cancel(); set_cancelled(); } - virtual void CancelOnMessageLoopThread() OVERRIDE { + virtual void CancelOnMessageLoopThread() override { if (impl_.get()) impl_->Cancel(); set_cancelled(); diff --git a/base/files/file_path_watcher_stub.cc b/base/files/file_path_watcher_stub.cc index afca0da..d7ad206 100644 --- a/base/files/file_path_watcher_stub.cc +++ b/base/files/file_path_watcher_stub.cc @@ -15,13 +15,13 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate { public: virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE { + const FilePathWatcher::Callback& callback) override { return false; } - virtual void Cancel() OVERRIDE {} + virtual void Cancel() override {} - virtual void CancelOnMessageLoopThread() OVERRIDE {} + virtual void CancelOnMessageLoopThread() override {} protected: virtual ~FilePathWatcherImpl() {} diff --git a/base/files/file_path_watcher_win.cc b/base/files/file_path_watcher_win.cc index 54a2388..98169ab 100644 --- a/base/files/file_path_watcher_win.cc +++ b/base/files/file_path_watcher_win.cc @@ -30,13 +30,13 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate, // FilePathWatcher::PlatformDelegate overrides. virtual bool Watch(const FilePath& path, bool recursive, - const FilePathWatcher::Callback& callback) OVERRIDE; - virtual void Cancel() OVERRIDE; + const FilePathWatcher::Callback& callback) override; + virtual void Cancel() override; // Deletion of the FilePathWatcher will call Cancel() to dispose of this // object in the right thread. This also observes destruction of the required // cleanup thread, in case it quits before Cancel() is called. - virtual void WillDestroyCurrentMessageLoop() OVERRIDE; + virtual void WillDestroyCurrentMessageLoop() override; // Callback from MessageLoopForIO. virtual void OnObjectSignaled(HANDLE object); @@ -59,7 +59,7 @@ class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate, void DestroyWatch(); // Cleans up and stops observing the |message_loop_| thread. - void CancelOnMessageLoopThread() OVERRIDE; + void CancelOnMessageLoopThread() override; // Callback to notify upon changes. FilePathWatcher::Callback callback_; diff --git a/base/files/file_proxy_unittest.cc b/base/files/file_proxy_unittest.cc index 2c62fa9..0034a1c 100644 --- a/base/files/file_proxy_unittest.cc +++ b/base/files/file_proxy_unittest.cc @@ -24,7 +24,7 @@ class FileProxyTest : public testing::Test { bytes_written_(-1), weak_factory_(this) {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { ASSERT_TRUE(dir_.CreateUniqueTempDir()); ASSERT_TRUE(file_thread_.Start()); } diff --git a/base/files/file_util_proxy_unittest.cc b/base/files/file_util_proxy_unittest.cc index a18cd43..87ae66a 100644 --- a/base/files/file_util_proxy_unittest.cc +++ b/base/files/file_util_proxy_unittest.cc @@ -23,7 +23,7 @@ class FileUtilProxyTest : public testing::Test { bytes_written_(-1), weak_factory_(this) {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { ASSERT_TRUE(dir_.CreateUniqueTempDir()); ASSERT_TRUE(file_thread_.Start()); } diff --git a/base/files/file_util_unittest.cc b/base/files/file_util_unittest.cc index 47dec30..b3e345c 100644 --- a/base/files/file_util_unittest.cc +++ b/base/files/file_util_unittest.cc @@ -184,7 +184,7 @@ const int FILES_AND_DIRECTORIES = // to be a PlatformTest class FileUtilTest : public PlatformTest { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { PlatformTest::SetUp(); ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); } @@ -2151,7 +2151,7 @@ TEST_F(FileUtilTest, IsDirectoryEmpty) { // with a common SetUp() method. class VerifyPathControlledByUserTest : public FileUtilTest { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { FileUtilTest::SetUp(); // Create a basic structure used by each test. diff --git a/base/files/important_file_writer_unittest.cc b/base/files/important_file_writer_unittest.cc index c55f0cc..71242ee 100644 --- a/base/files/important_file_writer_unittest.cc +++ b/base/files/important_file_writer_unittest.cc @@ -33,7 +33,7 @@ class DataSerializer : public ImportantFileWriter::DataSerializer { explicit DataSerializer(const std::string& data) : data_(data) { } - virtual bool SerializeData(std::string* output) OVERRIDE { + virtual bool SerializeData(std::string* output) override { output->assign(data_); return true; } diff --git a/base/files/memory_mapped_file_unittest.cc b/base/files/memory_mapped_file_unittest.cc index 6627d40..36999bf 100644 --- a/base/files/memory_mapped_file_unittest.cc +++ b/base/files/memory_mapped_file_unittest.cc @@ -29,7 +29,7 @@ bool CheckBufferContents(const uint8* data, size_t size, size_t offset) { class MemoryMappedFileTest : public PlatformTest { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { PlatformTest::SetUp(); CreateTemporaryFile(&temp_file_path_); } diff --git a/base/json/json_file_value_serializer.h b/base/json/json_file_value_serializer.h index 8006373..fc12b6b 100644 --- a/base/json/json_file_value_serializer.h +++ b/base/json/json_file_value_serializer.h @@ -32,7 +32,7 @@ class BASE_EXPORT JSONFileValueSerializer : public base::ValueSerializer { // Attempt to serialize the data structure represented by Value into // JSON. If the return value is true, the result will have been written // into the file whose name was passed into the constructor. - virtual bool Serialize(const base::Value& root) OVERRIDE; + virtual bool Serialize(const base::Value& root) override; // Equivalent to Serialize(root) except binary values are omitted from the // output. @@ -46,7 +46,7 @@ class BASE_EXPORT JSONFileValueSerializer : public base::ValueSerializer { // error message including the location of the error if appropriate. // The caller takes ownership of the returned value. virtual base::Value* Deserialize(int* error_code, - std::string* error_message) OVERRIDE; + std::string* error_message) override; // This enum is designed to safely overlap with JSONReader::JsonParseError. enum JsonFileError { diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc index 32e55e8..a74da5f 100644 --- a/base/json/json_parser.cc +++ b/base/json/json_parser.cc @@ -37,7 +37,7 @@ class DictionaryHiddenRootValue : public base::DictionaryValue { DictionaryValue::Swap(static_cast<DictionaryValue*>(root)); } - virtual void Swap(DictionaryValue* other) OVERRIDE { + virtual void Swap(DictionaryValue* other) override { DVLOG(1) << "Swap()ing a DictionaryValue inefficiently."; // First deep copy to convert JSONStringValue to std::string and swap that @@ -56,7 +56,7 @@ class DictionaryHiddenRootValue : public base::DictionaryValue { // the method below. virtual bool RemoveWithoutPathExpansion(const std::string& key, - scoped_ptr<Value>* out) OVERRIDE { + scoped_ptr<Value>* out) override { // If the caller won't take ownership of the removed value, just call up. if (!out) return DictionaryValue::RemoveWithoutPathExpansion(key, out); @@ -87,7 +87,7 @@ class ListHiddenRootValue : public base::ListValue { ListValue::Swap(static_cast<ListValue*>(root)); } - virtual void Swap(ListValue* other) OVERRIDE { + virtual void Swap(ListValue* other) override { DVLOG(1) << "Swap()ing a ListValue inefficiently."; // First deep copy to convert JSONStringValue to std::string and swap that @@ -102,7 +102,7 @@ class ListHiddenRootValue : public base::ListValue { ListValue::Swap(copy.get()); } - virtual bool Remove(size_t index, scoped_ptr<Value>* out) OVERRIDE { + virtual bool Remove(size_t index, scoped_ptr<Value>* out) override { // If the caller won't take ownership of the removed value, just call up. if (!out) return ListValue::Remove(index, out); @@ -137,18 +137,18 @@ class JSONStringValue : public base::Value { } // Overridden from base::Value: - virtual bool GetAsString(std::string* out_value) const OVERRIDE { + virtual bool GetAsString(std::string* out_value) const override { string_piece_.CopyToString(out_value); return true; } - virtual bool GetAsString(string16* out_value) const OVERRIDE { + virtual bool GetAsString(string16* out_value) const override { *out_value = UTF8ToUTF16(string_piece_); return true; } - virtual Value* DeepCopy() const OVERRIDE { + virtual Value* DeepCopy() const override { return new StringValue(string_piece_.as_string()); } - virtual bool Equals(const Value* other) const OVERRIDE { + virtual bool Equals(const Value* other) const override { std::string other_string; return other->IsType(TYPE_STRING) && other->GetAsString(&other_string) && StringPiece(other_string) == string_piece_; diff --git a/base/json/json_string_value_serializer.h b/base/json/json_string_value_serializer.h index 014ef9f..7fc5c6e 100644 --- a/base/json/json_string_value_serializer.h +++ b/base/json/json_string_value_serializer.h @@ -38,7 +38,7 @@ class BASE_EXPORT JSONStringValueSerializer : public base::ValueSerializer { // Attempt to serialize the data structure represented by Value into // JSON. If the return value is true, the result will have been written // into the string passed into the constructor. - virtual bool Serialize(const base::Value& root) OVERRIDE; + virtual bool Serialize(const base::Value& root) override; // Equivalent to Serialize(root) except binary values are omitted from the // output. @@ -52,7 +52,7 @@ class BASE_EXPORT JSONStringValueSerializer : public base::ValueSerializer { // error message including the location of the error if appropriate. // The caller takes ownership of the returned value. virtual base::Value* Deserialize(int* error_code, - std::string* error_message) OVERRIDE; + std::string* error_message) override; void set_pretty_print(bool new_value) { pretty_print_ = new_value; } bool pretty_print() { return pretty_print_; } diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h index cf3c74f..f049d9a 100644 --- a/base/json/json_value_converter.h +++ b/base/json/json_value_converter.h @@ -123,7 +123,7 @@ class FieldConverter : public FieldConverterBase<StructType> { } virtual bool ConvertField( - const base::Value& value, StructType* dst) const OVERRIDE { + const base::Value& value, StructType* dst) const override { return value_converter_->Convert(value, &(dst->*field_pointer_)); } @@ -141,7 +141,7 @@ class BasicValueConverter<int> : public ValueConverter<int> { public: BasicValueConverter() {} - virtual bool Convert(const base::Value& value, int* field) const OVERRIDE { + virtual bool Convert(const base::Value& value, int* field) const override { return value.GetAsInteger(field); } @@ -155,7 +155,7 @@ class BasicValueConverter<std::string> : public ValueConverter<std::string> { BasicValueConverter() {} virtual bool Convert( - const base::Value& value, std::string* field) const OVERRIDE { + const base::Value& value, std::string* field) const override { return value.GetAsString(field); } @@ -169,7 +169,7 @@ class BasicValueConverter<string16> : public ValueConverter<string16> { BasicValueConverter() {} virtual bool Convert( - const base::Value& value, string16* field) const OVERRIDE { + const base::Value& value, string16* field) const override { return value.GetAsString(field); } @@ -182,7 +182,7 @@ class BasicValueConverter<double> : public ValueConverter<double> { public: BasicValueConverter() {} - virtual bool Convert(const base::Value& value, double* field) const OVERRIDE { + virtual bool Convert(const base::Value& value, double* field) const override { return value.GetAsDouble(field); } @@ -195,7 +195,7 @@ class BasicValueConverter<bool> : public ValueConverter<bool> { public: BasicValueConverter() {} - virtual bool Convert(const base::Value& value, bool* field) const OVERRIDE { + virtual bool Convert(const base::Value& value, bool* field) const override { return value.GetAsBoolean(field); } @@ -212,7 +212,7 @@ class ValueFieldConverter : public ValueConverter<FieldType> { : convert_func_(convert_func) {} virtual bool Convert(const base::Value& value, - FieldType* field) const OVERRIDE { + FieldType* field) const override { return convert_func_(&value, field); } @@ -231,7 +231,7 @@ class CustomFieldConverter : public ValueConverter<FieldType> { : convert_func_(convert_func) {} virtual bool Convert(const base::Value& value, - FieldType* field) const OVERRIDE { + FieldType* field) const override { std::string string_value; return value.GetAsString(&string_value) && convert_func_(string_value, field); @@ -249,7 +249,7 @@ class NestedValueConverter : public ValueConverter<NestedType> { NestedValueConverter() {} virtual bool Convert( - const base::Value& value, NestedType* field) const OVERRIDE { + const base::Value& value, NestedType* field) const override { return converter_.Convert(value, field); } @@ -264,7 +264,7 @@ class RepeatedValueConverter : public ValueConverter<ScopedVector<Element> > { RepeatedValueConverter() {} virtual bool Convert( - const base::Value& value, ScopedVector<Element>* field) const OVERRIDE { + const base::Value& value, ScopedVector<Element>* field) const override { const base::ListValue* list = NULL; if (!value.GetAsList(&list)) { // The field is not a list. @@ -300,7 +300,7 @@ class RepeatedMessageConverter RepeatedMessageConverter() {} virtual bool Convert(const base::Value& value, - ScopedVector<NestedType>* field) const OVERRIDE { + ScopedVector<NestedType>* field) const override { const base::ListValue* list = NULL; if (!value.GetAsList(&list)) return false; @@ -337,7 +337,7 @@ class RepeatedCustomValueConverter : convert_func_(convert_func) {} virtual bool Convert(const base::Value& value, - ScopedVector<NestedType>* field) const OVERRIDE { + ScopedVector<NestedType>* field) const override { const base::ListValue* list = NULL; if (!value.GetAsList(&list)) return false; diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc index 3be8bbf..dc43693 100644 --- a/base/json/json_value_serializer_unittest.cc +++ b/base/json/json_value_serializer_unittest.cc @@ -372,7 +372,7 @@ TEST(JSONValueSerializerTest, JSONReaderComments) { class JSONFileValueSerializerTest : public testing::Test { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); } diff --git a/base/lazy_instance_unittest.cc b/base/lazy_instance_unittest.cc index e25366e..bf293c7 100644 --- a/base/lazy_instance_unittest.cc +++ b/base/lazy_instance_unittest.cc @@ -46,7 +46,7 @@ class SlowDelegate : public base::DelegateSimpleThread::Delegate { explicit SlowDelegate(base::LazyInstance<SlowConstructor>* lazy) : lazy_(lazy) {} - virtual void Run() OVERRIDE { + virtual void Run() override { EXPECT_EQ(12, lazy_->Get().some_int()); EXPECT_EQ(12, lazy_->Pointer()->some_int()); } diff --git a/base/mac/libdispatch_task_runner.h b/base/mac/libdispatch_task_runner.h index b1d90e2..afe1fb7 100644 --- a/base/mac/libdispatch_task_runner.h +++ b/base/mac/libdispatch_task_runner.h @@ -40,14 +40,14 @@ class BASE_EXPORT LibDispatchTaskRunner : public base::SingleThreadTaskRunner { // base::TaskRunner: virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - base::TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + base::TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; // base::SequencedTaskRunner: virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const Closure& task, - base::TimeDelta delay) OVERRIDE; + base::TimeDelta delay) override; // This blocks the calling thread until all work on the dispatch queue has // been run and the queue has been destroyed. Destroying a queue requires diff --git a/base/mac/libdispatch_task_runner_unittest.cc b/base/mac/libdispatch_task_runner_unittest.cc index a4f3202..cad0efa 100644 --- a/base/mac/libdispatch_task_runner_unittest.cc +++ b/base/mac/libdispatch_task_runner_unittest.cc @@ -12,7 +12,7 @@ class LibDispatchTaskRunnerTest : public testing::Test { public: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { task_runner_ = new base::mac::LibDispatchTaskRunner( "org.chromium.LibDispatchTaskRunnerTest"); } diff --git a/base/memory/discardable_memory_ashmem.h b/base/memory/discardable_memory_ashmem.h index 8436f5d..392f290 100644 --- a/base/memory/discardable_memory_ashmem.h +++ b/base/memory/discardable_memory_ashmem.h @@ -30,14 +30,14 @@ class DiscardableMemoryAshmem bool Initialize(); // Overridden from DiscardableMemory: - virtual DiscardableMemoryLockStatus Lock() OVERRIDE; - virtual void Unlock() OVERRIDE; - virtual void* Memory() const OVERRIDE; + virtual DiscardableMemoryLockStatus Lock() override; + virtual void Unlock() override; + virtual void* Memory() const override; // Overridden from internal::DiscardableMemoryManagerAllocation: - virtual bool AllocateAndAcquireLock() OVERRIDE; - virtual void ReleaseLock() OVERRIDE; - virtual void Purge() OVERRIDE; + virtual bool AllocateAndAcquireLock() override; + virtual void ReleaseLock() override; + virtual void Purge() override; private: const size_t bytes_; diff --git a/base/memory/discardable_memory_emulated.h b/base/memory/discardable_memory_emulated.h index d928513..33889ad 100644 --- a/base/memory/discardable_memory_emulated.h +++ b/base/memory/discardable_memory_emulated.h @@ -31,14 +31,14 @@ class DiscardableMemoryEmulated bool Initialize(); // Overridden from DiscardableMemory: - virtual DiscardableMemoryLockStatus Lock() OVERRIDE; - virtual void Unlock() OVERRIDE; - virtual void* Memory() const OVERRIDE; + virtual DiscardableMemoryLockStatus Lock() override; + virtual void Unlock() override; + virtual void* Memory() const override; // Overridden from internal::DiscardableMemoryManagerAllocation: - virtual bool AllocateAndAcquireLock() OVERRIDE; - virtual void ReleaseLock() OVERRIDE {} - virtual void Purge() OVERRIDE; + virtual bool AllocateAndAcquireLock() override; + virtual void ReleaseLock() override {} + virtual void Purge() override; private: const size_t bytes_; diff --git a/base/memory/discardable_memory_mac.cc b/base/memory/discardable_memory_mac.cc index fa6a231..231eb17 100644 --- a/base/memory/discardable_memory_mac.cc +++ b/base/memory/discardable_memory_mac.cc @@ -56,7 +56,7 @@ class DiscardableMemoryMac } // Overridden from DiscardableMemory: - virtual DiscardableMemoryLockStatus Lock() OVERRIDE { + virtual DiscardableMemoryLockStatus Lock() override { DCHECK(!is_locked_); bool purged = false; @@ -68,19 +68,19 @@ class DiscardableMemoryMac : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS; } - virtual void Unlock() OVERRIDE { + virtual void Unlock() override { DCHECK(is_locked_); g_shared_state.Pointer()->manager.ReleaseLock(this); is_locked_ = false; } - virtual void* Memory() const OVERRIDE { + virtual void* Memory() const override { DCHECK(is_locked_); return reinterpret_cast<void*>(memory_.address()); } // Overridden from internal::DiscardableMemoryManagerAllocation: - virtual bool AllocateAndAcquireLock() OVERRIDE { + virtual bool AllocateAndAcquireLock() override { kern_return_t ret; bool persistent; if (!memory_.size()) { @@ -123,7 +123,7 @@ class DiscardableMemoryMac return persistent; } - virtual void ReleaseLock() OVERRIDE { + virtual void ReleaseLock() override { int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT; kern_return_t ret = vm_purgable_control(mach_task_self(), memory_.address(), @@ -141,7 +141,7 @@ class DiscardableMemoryMac #endif } - virtual void Purge() OVERRIDE { + virtual void Purge() override { memory_.reset(); } diff --git a/base/memory/discardable_memory_malloc.h b/base/memory/discardable_memory_malloc.h index 7729ce5..e22d515 100644 --- a/base/memory/discardable_memory_malloc.h +++ b/base/memory/discardable_memory_malloc.h @@ -18,9 +18,9 @@ class DiscardableMemoryMalloc : public DiscardableMemory { bool Initialize(); // Overridden from DiscardableMemory: - virtual DiscardableMemoryLockStatus Lock() OVERRIDE; - virtual void Unlock() OVERRIDE; - virtual void* Memory() const OVERRIDE; + virtual DiscardableMemoryLockStatus Lock() override; + virtual void Unlock() override; + virtual void* Memory() const override; private: scoped_ptr<uint8, FreeDeleter> memory_; diff --git a/base/memory/discardable_memory_manager_unittest.cc b/base/memory/discardable_memory_manager_unittest.cc index 674499f..18ceec3 100644 --- a/base/memory/discardable_memory_manager_unittest.cc +++ b/base/memory/discardable_memory_manager_unittest.cc @@ -18,18 +18,18 @@ class TestAllocationImpl : public internal::DiscardableMemoryManagerAllocation { virtual ~TestAllocationImpl() { DCHECK(!is_locked_); } // Overridden from internal::DiscardableMemoryManagerAllocation: - virtual bool AllocateAndAcquireLock() OVERRIDE { + virtual bool AllocateAndAcquireLock() override { bool was_allocated = is_allocated_; is_allocated_ = true; DCHECK(!is_locked_); is_locked_ = true; return was_allocated; } - virtual void ReleaseLock() OVERRIDE { + virtual void ReleaseLock() override { DCHECK(is_locked_); is_locked_ = false; } - virtual void Purge() OVERRIDE { + virtual void Purge() override { DCHECK(is_allocated_); is_allocated_ = false; } @@ -58,7 +58,7 @@ class TestDiscardableMemoryManagerImpl private: // Overriden from internal::DiscardableMemoryManager: - virtual TimeTicks Now() const OVERRIDE { return now_; } + virtual TimeTicks Now() const override { return now_; } TimeTicks now_; }; @@ -456,9 +456,9 @@ class ThreadedDiscardableMemoryManagerTest : memory_usage_thread_("memory_usage_thread"), thread_sync_(true, false) {} - virtual void SetUp() OVERRIDE { memory_usage_thread_.Start(); } + virtual void SetUp() override { memory_usage_thread_.Start(); } - virtual void TearDown() OVERRIDE { memory_usage_thread_.Stop(); } + virtual void TearDown() override { memory_usage_thread_.Stop(); } void UseMemoryHelper() { size_t size = 1024; diff --git a/base/memory/linked_ptr_unittest.cc b/base/memory/linked_ptr_unittest.cc index 8b938f2..2dbc4bd 100644 --- a/base/memory/linked_ptr_unittest.cc +++ b/base/memory/linked_ptr_unittest.cc @@ -26,7 +26,7 @@ struct A { struct B: public A { B() { history += base::StringPrintf("B%d ctor\n", mynum); } virtual ~B() { history += base::StringPrintf("B%d dtor\n", mynum); } - virtual void Use() OVERRIDE { + virtual void Use() override { history += base::StringPrintf("B%d use\n", mynum); } }; diff --git a/base/memory/ref_counted_memory.h b/base/memory/ref_counted_memory.h index a238c3a..f7acc65 100644 --- a/base/memory/ref_counted_memory.h +++ b/base/memory/ref_counted_memory.h @@ -52,8 +52,8 @@ class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory { length_(length) {} // Overridden from RefCountedMemory: - virtual const unsigned char* front() const OVERRIDE; - virtual size_t size() const OVERRIDE; + virtual const unsigned char* front() const override; + virtual size_t size() const override; private: virtual ~RefCountedStaticMemory(); @@ -81,8 +81,8 @@ class BASE_EXPORT RefCountedBytes : public RefCountedMemory { static RefCountedBytes* TakeVector(std::vector<unsigned char>* to_destroy); // Overridden from RefCountedMemory: - virtual const unsigned char* front() const OVERRIDE; - virtual size_t size() const OVERRIDE; + virtual const unsigned char* front() const override; + virtual size_t size() const override; const std::vector<unsigned char>& data() const { return data_; } std::vector<unsigned char>& data() { return data_; } @@ -107,8 +107,8 @@ class BASE_EXPORT RefCountedString : public RefCountedMemory { static RefCountedString* TakeString(std::string* to_destroy); // Overridden from RefCountedMemory: - virtual const unsigned char* front() const OVERRIDE; - virtual size_t size() const OVERRIDE; + virtual const unsigned char* front() const override; + virtual size_t size() const override; const std::string& data() const { return data_; } std::string& data() { return data_; } @@ -129,8 +129,8 @@ class BASE_EXPORT RefCountedMallocedMemory : public base::RefCountedMemory { RefCountedMallocedMemory(void* data, size_t length); // Overridden from RefCountedMemory: - virtual const unsigned char* front() const OVERRIDE; - virtual size_t size() const OVERRIDE; + virtual const unsigned char* front() const override; + virtual size_t size() const override; private: virtual ~RefCountedMallocedMemory(); diff --git a/base/memory/scoped_ptr_unittest.cc b/base/memory/scoped_ptr_unittest.cc index cfdebeb..2ea44e9 100644 --- a/base/memory/scoped_ptr_unittest.cc +++ b/base/memory/scoped_ptr_unittest.cc @@ -27,9 +27,9 @@ class ConDecLogger : public ConDecLoggerParent { explicit ConDecLogger(int* ptr) { SetPtr(ptr); } virtual ~ConDecLogger() { --*ptr_; } - virtual void SetPtr(int* ptr) OVERRIDE { ptr_ = ptr; ++*ptr_; } + virtual void SetPtr(int* ptr) override { ptr_ = ptr; ++*ptr_; } - virtual int SomeMeth(int x) const OVERRIDE { return x; } + virtual int SomeMeth(int x) const override { return x; } private: int* ptr_; diff --git a/base/memory/scoped_vector_unittest.cc b/base/memory/scoped_vector_unittest.cc index efcc047..ae870d5 100644 --- a/base/memory/scoped_vector_unittest.cc +++ b/base/memory/scoped_vector_unittest.cc @@ -66,7 +66,7 @@ class LifeCycleWatcher : public LifeCycleObject::Observer { // Assert INITIAL -> CONSTRUCTED and no LifeCycleObject associated with this // LifeCycleWatcher. - virtual void OnLifeCycleConstruct(LifeCycleObject* object) OVERRIDE { + virtual void OnLifeCycleConstruct(LifeCycleObject* object) override { ASSERT_EQ(LC_INITIAL, life_cycle_state_); ASSERT_EQ(NULL, constructed_life_cycle_object_.get()); life_cycle_state_ = LC_CONSTRUCTED; @@ -75,7 +75,7 @@ class LifeCycleWatcher : public LifeCycleObject::Observer { // Assert CONSTRUCTED -> DESTROYED and the |object| being destroyed is the // same one we saw constructed. - virtual void OnLifeCycleDestroy(LifeCycleObject* object) OVERRIDE { + virtual void OnLifeCycleDestroy(LifeCycleObject* object) override { ASSERT_EQ(LC_CONSTRUCTED, life_cycle_state_); LifeCycleObject* constructed_life_cycle_object = constructed_life_cycle_object_.release(); diff --git a/base/memory/shared_memory_unittest.cc b/base/memory/shared_memory_unittest.cc index 34c1106..775e1c8 100644 --- a/base/memory/shared_memory_unittest.cc +++ b/base/memory/shared_memory_unittest.cc @@ -55,7 +55,7 @@ class MultipleThreadMain : public PlatformThread::Delegate { } // PlatformThread::Delegate interface. - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { #if defined(OS_MACOSX) mac::ScopedNSAutoreleasePool pool; #endif @@ -104,7 +104,7 @@ class MultipleLockThread : public PlatformThread::Delegate { virtual ~MultipleLockThread() {} // PlatformThread::Delegate interface. - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { const uint32 kDataSize = sizeof(int); SharedMemoryHandle handle = NULL; { diff --git a/base/memory/singleton_unittest.cc b/base/memory/singleton_unittest.cc index 5d05904..41bd75c 100644 --- a/base/memory/singleton_unittest.cc +++ b/base/memory/singleton_unittest.cc @@ -154,7 +154,7 @@ class SingletonTest : public testing::Test { public: SingletonTest() {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { non_leak_called_ = false; leaky_called_ = false; static_called_ = false; diff --git a/base/message_loop/message_loop.h b/base/message_loop/message_loop.h index c9a9185..bc98251 100644 --- a/base/message_loop/message_loop.h +++ b/base/message_loop/message_loop.h @@ -442,9 +442,9 @@ class BASE_EXPORT MessageLoop : public MessagePump::Delegate { void HistogramEvent(int event); // MessagePump::Delegate methods: - virtual bool DoWork() OVERRIDE; - virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) OVERRIDE; - virtual bool DoIdleWork() OVERRIDE; + virtual bool DoWork() override; + virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) override; + virtual bool DoIdleWork() override; const Type type_; diff --git a/base/message_loop/message_loop_proxy_impl.h b/base/message_loop/message_loop_proxy_impl.h index b7f62b9..ca9543e 100644 --- a/base/message_loop/message_loop_proxy_impl.h +++ b/base/message_loop/message_loop_proxy_impl.h @@ -27,12 +27,12 @@ class BASE_EXPORT MessageLoopProxyImpl : public MessageLoopProxy { // MessageLoopProxy implementation virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const base::Closure& task, - base::TimeDelta delay) OVERRIDE; + base::TimeDelta delay) override; virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const base::Closure& task, - base::TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + base::TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; private: friend class RefCountedThreadSafe<MessageLoopProxyImpl>; diff --git a/base/message_loop/message_loop_proxy_impl_unittest.cc b/base/message_loop/message_loop_proxy_impl_unittest.cc index 81c9b0c..5f31140 100644 --- a/base/message_loop/message_loop_proxy_impl_unittest.cc +++ b/base/message_loop/message_loop_proxy_impl_unittest.cc @@ -38,14 +38,14 @@ class MessageLoopProxyImplTest : public testing::Test { } protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { io_thread_.reset(new Thread("MessageLoopProxyImplTest_IO")); file_thread_.reset(new Thread("MessageLoopProxyImplTest_File")); io_thread_->Start(); file_thread_->Start(); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { io_thread_->Stop(); file_thread_->Stop(); } diff --git a/base/message_loop/message_loop_proxy_unittest.cc b/base/message_loop/message_loop_proxy_unittest.cc index ada9080..673ed88 100644 --- a/base/message_loop/message_loop_proxy_unittest.cc +++ b/base/message_loop/message_loop_proxy_unittest.cc @@ -31,7 +31,7 @@ class MessageLoopProxyTest : public testing::Test { } protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { // Use SetUp() instead of the constructor to avoid posting a task to a // partialy constructed object. task_thread_.Start(); @@ -42,7 +42,7 @@ class MessageLoopProxyTest : public testing::Test { Bind(&MessageLoopProxyTest::BlockTaskThreadHelper, Unretained(this))); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { // Make sure the |task_thread_| is not blocked, and stop the thread // fully before destuction because its tasks may still depend on the // |thread_sync_| event. diff --git a/base/message_loop/message_loop_unittest.cc b/base/message_loop/message_loop_unittest.cc index b07ba0e0..1a42cc6 100644 --- a/base/message_loop/message_loop_unittest.cc +++ b/base/message_loop/message_loop_unittest.cc @@ -425,7 +425,7 @@ class DispatcherImpl : public MessagePumpDispatcher { public: DispatcherImpl() : dispatch_count_(0) {} - virtual uint32_t Dispatch(const NativeEvent& msg) OVERRIDE { + virtual uint32_t Dispatch(const NativeEvent& msg) override { ::TranslateMessage(&msg); ::DispatchMessage(&msg); // Do not count WM_TIMER since it is not what we post and it will cause @@ -666,14 +666,14 @@ class DummyTaskObserver : public MessageLoop::TaskObserver { virtual ~DummyTaskObserver() {} - virtual void WillProcessTask(const PendingTask& pending_task) OVERRIDE { + virtual void WillProcessTask(const PendingTask& pending_task) override { num_tasks_started_++; EXPECT_TRUE(pending_task.time_posted != TimeTicks()); EXPECT_LE(num_tasks_started_, num_tasks_); EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1); } - virtual void DidProcessTask(const PendingTask& pending_task) OVERRIDE { + virtual void DidProcessTask(const PendingTask& pending_task) override { num_tasks_processed_++; EXPECT_TRUE(pending_task.time_posted != TimeTicks()); EXPECT_LE(num_tasks_started_, num_tasks_); @@ -756,10 +756,10 @@ namespace { class QuitDelegate : public MessageLoopForIO::Watcher { public: - virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int fd) override { MessageLoop::current()->QuitWhenIdle(); } - virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE { + virtual void OnFileCanReadWithoutBlocking(int fd) override { MessageLoop::current()->QuitWhenIdle(); } }; @@ -857,7 +857,7 @@ class MLDestructionObserver : public MessageLoop::DestructionObserver { destruction_observer_called_(destruction_observer_called), task_destroyed_before_message_loop_(false) { } - virtual void WillDestroyCurrentMessageLoop() OVERRIDE { + virtual void WillDestroyCurrentMessageLoop() override { task_destroyed_before_message_loop_ = *task_destroyed_; *destruction_observer_called_ = true; } diff --git a/base/message_loop/message_pump_android.h b/base/message_loop/message_pump_android.h index 8a07a0f..9b4540f 100644 --- a/base/message_loop/message_pump_android.h +++ b/base/message_loop/message_pump_android.h @@ -24,10 +24,10 @@ class BASE_EXPORT MessagePumpForUI : public MessagePump { MessagePumpForUI(); virtual ~MessagePumpForUI(); - virtual void Run(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; - virtual void ScheduleWork() OVERRIDE; - virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE; + virtual void Run(Delegate* delegate) override; + virtual void Quit() override; + virtual void ScheduleWork() override; + virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override; virtual void Start(Delegate* delegate); diff --git a/base/message_loop/message_pump_default.h b/base/message_loop/message_pump_default.h index 19e7200..e9f7302 100644 --- a/base/message_loop/message_pump_default.h +++ b/base/message_loop/message_pump_default.h @@ -18,10 +18,10 @@ class BASE_EXPORT MessagePumpDefault : public MessagePump { virtual ~MessagePumpDefault(); // MessagePump methods: - virtual void Run(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; - virtual void ScheduleWork() OVERRIDE; - virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE; + virtual void Run(Delegate* delegate) override; + virtual void Quit() override; + virtual void ScheduleWork() override; + virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override; private: // This flag is set to false when Run should return. diff --git a/base/message_loop/message_pump_glib.h b/base/message_loop/message_pump_glib.h index a13493a..0f797c5 100644 --- a/base/message_loop/message_pump_glib.h +++ b/base/message_loop/message_pump_glib.h @@ -35,10 +35,10 @@ class BASE_EXPORT MessagePumpGlib : public MessagePump { void HandleDispatch(); // Overridden from MessagePump: - virtual void Run(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; - virtual void ScheduleWork() OVERRIDE; - virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE; + virtual void Run(Delegate* delegate) override; + virtual void Quit() override; + virtual void ScheduleWork() override; + virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override; private: bool ShouldQuit() const; diff --git a/base/message_loop/message_pump_glib_unittest.cc b/base/message_loop/message_pump_glib_unittest.cc index aaf6b4d..ae4fefe 100644 --- a/base/message_loop/message_pump_glib_unittest.cc +++ b/base/message_loop/message_pump_glib_unittest.cc @@ -161,11 +161,11 @@ class MessagePumpGLibTest : public testing::Test { MessagePumpGLibTest() : loop_(NULL), injector_(NULL) { } // Overridden from testing::Test: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { loop_ = new MessageLoop(MessageLoop::TYPE_UI); injector_ = new EventInjector(); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { delete injector_; injector_ = NULL; delete loop_; diff --git a/base/message_loop/message_pump_io_ios_unittest.cc b/base/message_loop/message_pump_io_ios_unittest.cc index e6dcc33..0bf8c08 100644 --- a/base/message_loop/message_pump_io_ios_unittest.cc +++ b/base/message_loop/message_pump_io_ios_unittest.cc @@ -20,7 +20,7 @@ class MessagePumpIOSForIOTest : public testing::Test { io_thread_("MessagePumpIOSForIOTestIOThread") {} virtual ~MessagePumpIOSForIOTest() {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { Thread::Options options(MessageLoop::TYPE_IO, 0); ASSERT_TRUE(io_thread_.StartWithOptions(options)); ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type()); @@ -30,7 +30,7 @@ class MessagePumpIOSForIOTest : public testing::Test { ASSERT_EQ(0, ret); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { if (IGNORE_EINTR(close(pipefds_[0])) < 0) PLOG(ERROR) << "close"; if (IGNORE_EINTR(close(pipefds_[1])) < 0) @@ -67,8 +67,8 @@ class StupidWatcher : public MessagePumpIOSForIO::Watcher { virtual ~StupidWatcher() {} // base:MessagePumpIOSForIO::Watcher interface - virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {} - virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {} + virtual void OnFileCanReadWithoutBlocking(int fd) override {} + virtual void OnFileCanWriteWithoutBlocking(int fd) override {} }; #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) @@ -96,11 +96,11 @@ class BaseWatcher : public MessagePumpIOSForIO::Watcher { virtual ~BaseWatcher() {} // MessagePumpIOSForIO::Watcher interface - virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); } - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); } @@ -118,7 +118,7 @@ class DeleteWatcher : public BaseWatcher { DCHECK(!controller_); } - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { DCHECK(controller_); delete controller_; controller_ = NULL; @@ -148,7 +148,7 @@ class StopWatcher : public BaseWatcher { virtual ~StopWatcher() {} - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { controller_->StopWatchingFileDescriptor(); if (fd_to_start_watching_ >= 0) { pump_->WatchFileDescriptor(fd_to_start_watching_, diff --git a/base/message_loop/message_pump_libevent.h b/base/message_loop/message_pump_libevent.h index f3a48a9..2f1812f 100644 --- a/base/message_loop/message_pump_libevent.h +++ b/base/message_loop/message_pump_libevent.h @@ -122,10 +122,10 @@ class BASE_EXPORT MessagePumpLibevent : public MessagePump { void RemoveIOObserver(IOObserver* obs); // MessagePump methods: - virtual void Run(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; - virtual void ScheduleWork() OVERRIDE; - virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE; + virtual void Run(Delegate* delegate) override; + virtual void Quit() override; + virtual void ScheduleWork() override; + virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override; private: friend class MessagePumpLibeventTest; diff --git a/base/message_loop/message_pump_libevent_unittest.cc b/base/message_loop/message_pump_libevent_unittest.cc index 9298d68..e598d76 100644 --- a/base/message_loop/message_pump_libevent_unittest.cc +++ b/base/message_loop/message_pump_libevent_unittest.cc @@ -23,7 +23,7 @@ class MessagePumpLibeventTest : public testing::Test { io_thread_("MessagePumpLibeventTestIOThread") {} virtual ~MessagePumpLibeventTest() {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { Thread::Options options(MessageLoop::TYPE_IO, 0); ASSERT_TRUE(io_thread_.StartWithOptions(options)); ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type()); @@ -31,7 +31,7 @@ class MessagePumpLibeventTest : public testing::Test { ASSERT_EQ(0, ret); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { if (IGNORE_EINTR(close(pipefds_[0])) < 0) PLOG(ERROR) << "close"; if (IGNORE_EINTR(close(pipefds_[1])) < 0) @@ -65,8 +65,8 @@ class StupidWatcher : public MessagePumpLibevent::Watcher { virtual ~StupidWatcher() {} // base:MessagePumpLibevent::Watcher interface - virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {} - virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {} + virtual void OnFileCanReadWithoutBlocking(int fd) override {} + virtual void OnFileCanWriteWithoutBlocking(int fd) override {} }; #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) @@ -100,11 +100,11 @@ class BaseWatcher : public MessagePumpLibevent::Watcher { virtual ~BaseWatcher() {} // base:MessagePumpLibevent::Watcher interface - virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); } - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); } @@ -122,7 +122,7 @@ class DeleteWatcher : public BaseWatcher { DCHECK(!controller_); } - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { DCHECK(controller_); delete controller_; controller_ = NULL; @@ -149,7 +149,7 @@ class StopWatcher : public BaseWatcher { virtual ~StopWatcher() {} - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { controller_->StopWatchingFileDescriptor(); } }; @@ -179,14 +179,14 @@ class NestedPumpWatcher : public MessagePumpLibevent::Watcher { NestedPumpWatcher() {} virtual ~NestedPumpWatcher() {} - virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE { + virtual void OnFileCanReadWithoutBlocking(int /* fd */) override { RunLoop runloop; MessageLoop::current()->PostTask(FROM_HERE, Bind(&QuitMessageLoopAndStart, runloop.QuitClosure())); runloop.Run(); } - virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {} + virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {} }; TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) { diff --git a/base/message_loop/message_pump_mac.h b/base/message_loop/message_pump_mac.h index f52bd76..d16db8c 100644 --- a/base/message_loop/message_pump_mac.h +++ b/base/message_loop/message_pump_mac.h @@ -88,12 +88,12 @@ class MessagePumpCFRunLoopBase : public MessagePump { // in the DoRun method. MessagePumpCFRunLoopBase::Run calls DoRun directly. // This arrangement is used because MessagePumpCFRunLoopBase needs to set // up and tear down things before and after the "meat" of DoRun. - virtual void Run(Delegate* delegate) OVERRIDE; + virtual void Run(Delegate* delegate) override; virtual void DoRun(Delegate* delegate) = 0; - virtual void ScheduleWork() OVERRIDE; - virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) OVERRIDE; - virtual void SetTimerSlack(TimerSlack timer_slack) OVERRIDE; + virtual void ScheduleWork() override; + virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override; + virtual void SetTimerSlack(TimerSlack timer_slack) override; protected: // Accessors for private data members to be used by subclasses. @@ -222,11 +222,11 @@ class BASE_EXPORT MessagePumpCFRunLoop : public MessagePumpCFRunLoopBase { MessagePumpCFRunLoop(); virtual ~MessagePumpCFRunLoop(); - virtual void DoRun(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; + virtual void DoRun(Delegate* delegate) override; + virtual void Quit() override; private: - virtual void EnterExitRunLoop(CFRunLoopActivity activity) OVERRIDE; + virtual void EnterExitRunLoop(CFRunLoopActivity activity) override; // True if Quit is called to stop the innermost MessagePump // (innermost_quittable_) but some other CFRunLoopRun loop (nesting_level_) @@ -241,8 +241,8 @@ class BASE_EXPORT MessagePumpNSRunLoop : public MessagePumpCFRunLoopBase { MessagePumpNSRunLoop(); virtual ~MessagePumpNSRunLoop(); - virtual void DoRun(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; + virtual void DoRun(Delegate* delegate) override; + virtual void Quit() override; private: // A source that doesn't do anything but provide something signalable @@ -264,8 +264,8 @@ class MessagePumpUIApplication : public MessagePumpCFRunLoopBase { public: MessagePumpUIApplication(); virtual ~MessagePumpUIApplication(); - virtual void DoRun(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; + virtual void DoRun(Delegate* delegate) override; + virtual void Quit() override; // This message pump can not spin the main message loop directly. Instead, // call |Attach()| to set up a delegate. It is an error to call |Run()|. @@ -284,8 +284,8 @@ class MessagePumpNSApplication : public MessagePumpCFRunLoopBase { MessagePumpNSApplication(); virtual ~MessagePumpNSApplication(); - virtual void DoRun(Delegate* delegate) OVERRIDE; - virtual void Quit() OVERRIDE; + virtual void DoRun(Delegate* delegate) override; + virtual void Quit() override; private: // False after Quit is called. @@ -308,7 +308,7 @@ class MessagePumpCrApplication : public MessagePumpNSApplication { protected: // Returns nil if NSApp is currently in the middle of calling // -sendEvent. Requires NSApp implementing CrAppProtocol. - virtual AutoreleasePoolType* CreateAutoreleasePool() OVERRIDE; + virtual AutoreleasePoolType* CreateAutoreleasePool() override; private: DISALLOW_COPY_AND_ASSIGN(MessagePumpCrApplication); diff --git a/base/message_loop/message_pump_perftest.cc b/base/message_loop/message_pump_perftest.cc index 7c7b400..40550e1 100644 --- a/base/message_loop/message_pump_perftest.cc +++ b/base/message_loop/message_pump_perftest.cc @@ -232,12 +232,12 @@ class FakeMessagePump : public MessagePump { FakeMessagePump() {} virtual ~FakeMessagePump() {} - virtual void Run(Delegate* delegate) OVERRIDE {} + virtual void Run(Delegate* delegate) override {} - virtual void Quit() OVERRIDE {} - virtual void ScheduleWork() OVERRIDE {} + virtual void Quit() override {} + virtual void ScheduleWork() override {} virtual void ScheduleDelayedWork( - const TimeTicks& delayed_work_time) OVERRIDE {} + const TimeTicks& delayed_work_time) override {} }; class PostTaskTest : public testing::Test { diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc index 52ce8554..b3a6eb3 100644 --- a/base/metrics/field_trial_unittest.cc +++ b/base/metrics/field_trial_unittest.cc @@ -49,7 +49,7 @@ class TestFieldTrialObserver : public FieldTrialList::Observer { } virtual void OnFieldTrialGroupFinalized(const std::string& trial, - const std::string& group) OVERRIDE { + const std::string& group) override { trial_name_ = trial; group_name_ = group; } diff --git a/base/metrics/histogram.h b/base/metrics/histogram.h index 816458d..47cfc79 100644 --- a/base/metrics/histogram.h +++ b/base/metrics/histogram.h @@ -359,7 +359,7 @@ class BASE_EXPORT Histogram : public HistogramBase { // produce a false-alarm if a race occurred in the reading of the data during // a SnapShot process, but should otherwise be false at all times (unless we // have memory over-writes, or DRAM failures). - virtual int FindCorruption(const HistogramSamples& samples) const OVERRIDE; + virtual int FindCorruption(const HistogramSamples& samples) const override; //---------------------------------------------------------------------------- // Accessors for factory construction, serialization and testing. @@ -382,17 +382,17 @@ class BASE_EXPORT Histogram : public HistogramBase { size_t* bucket_count); // HistogramBase implementation: - virtual HistogramType GetHistogramType() const OVERRIDE; + virtual HistogramType GetHistogramType() const override; virtual bool HasConstructionArguments( Sample expected_minimum, Sample expected_maximum, - size_t expected_bucket_count) const OVERRIDE; - virtual void Add(Sample value) OVERRIDE; - virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE; - virtual void AddSamples(const HistogramSamples& samples) OVERRIDE; - virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE; - virtual void WriteHTMLGraph(std::string* output) const OVERRIDE; - virtual void WriteAscii(std::string* output) const OVERRIDE; + size_t expected_bucket_count) const override; + virtual void Add(Sample value) override; + virtual scoped_ptr<HistogramSamples> SnapshotSamples() const override; + virtual void AddSamples(const HistogramSamples& samples) override; + virtual bool AddSamplesFromPickle(PickleIterator* iter) override; + virtual void WriteHTMLGraph(std::string* output) const override; + virtual void WriteAscii(std::string* output) const override; protected: // |ranges| should contain the underflow and overflow buckets. See top @@ -405,7 +405,7 @@ class BASE_EXPORT Histogram : public HistogramBase { virtual ~Histogram(); // HistogramBase implementation: - virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE; + virtual bool SerializeInfoImpl(Pickle* pickle) const override; // Method to override to skip the display of the i'th bucket if it's empty. virtual bool PrintEmptyBucket(size_t index) const; @@ -458,11 +458,11 @@ class BASE_EXPORT Histogram : public HistogramBase { std::string* output) const; // WriteJSON calls these. - virtual void GetParameters(DictionaryValue* params) const OVERRIDE; + virtual void GetParameters(DictionaryValue* params) const override; virtual void GetCountAndBucketData(Count* count, int64* sum, - ListValue* buckets) const OVERRIDE; + ListValue* buckets) const override; // Does not own this object. Should get from StatisticsRecorder. const BucketRanges* bucket_ranges_; @@ -521,7 +521,7 @@ class BASE_EXPORT LinearHistogram : public Histogram { BucketRanges* ranges); // Overridden from Histogram: - virtual HistogramType GetHistogramType() const OVERRIDE; + virtual HistogramType GetHistogramType() const override; protected: LinearHistogram(const std::string& name, @@ -529,15 +529,15 @@ class BASE_EXPORT LinearHistogram : public Histogram { Sample maximum, const BucketRanges* ranges); - virtual double GetBucketSize(Count current, size_t i) const OVERRIDE; + virtual double GetBucketSize(Count current, size_t i) const override; // If we have a description for a bucket, then return that. Otherwise // let parent class provide a (numeric) description. - virtual const std::string GetAsciiBucketRange(size_t i) const OVERRIDE; + virtual const std::string GetAsciiBucketRange(size_t i) const override; // Skip printing of name for numeric range if we have a name (and if this is // an empty bucket). - virtual bool PrintEmptyBucket(size_t index) const OVERRIDE; + virtual bool PrintEmptyBucket(size_t index) const override; private: friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo( @@ -560,7 +560,7 @@ class BASE_EXPORT BooleanHistogram : public LinearHistogram { public: static HistogramBase* FactoryGet(const std::string& name, int32 flags); - virtual HistogramType GetHistogramType() const OVERRIDE; + virtual HistogramType GetHistogramType() const override; private: BooleanHistogram(const std::string& name, const BucketRanges* ranges); @@ -586,7 +586,7 @@ class BASE_EXPORT CustomHistogram : public Histogram { int32 flags); // Overridden from Histogram: - virtual HistogramType GetHistogramType() const OVERRIDE; + virtual HistogramType GetHistogramType() const override; // Helper method for transforming an array of valid enumeration values // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION. @@ -601,9 +601,9 @@ class BASE_EXPORT CustomHistogram : public Histogram { const BucketRanges* ranges); // HistogramBase implementation: - virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE; + virtual bool SerializeInfoImpl(Pickle* pickle) const override; - virtual double GetBucketSize(Count current, size_t i) const OVERRIDE; + virtual double GetBucketSize(Count current, size_t i) const override; private: friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo( diff --git a/base/metrics/histogram_delta_serialization.h b/base/metrics/histogram_delta_serialization.h index ccadb12..037d0b5 100644 --- a/base/metrics/histogram_delta_serialization.h +++ b/base/metrics/histogram_delta_serialization.h @@ -39,12 +39,12 @@ class BASE_EXPORT HistogramDeltaSerialization : public HistogramFlattener { private: // HistogramFlattener implementation. virtual void RecordDelta(const HistogramBase& histogram, - const HistogramSamples& snapshot) OVERRIDE; + const HistogramSamples& snapshot) override; virtual void InconsistencyDetected( - HistogramBase::Inconsistency problem) OVERRIDE; + HistogramBase::Inconsistency problem) override; virtual void UniqueInconsistencyDetected( - HistogramBase::Inconsistency problem) OVERRIDE; - virtual void InconsistencyDetectedInLoggedCount(int amount) OVERRIDE; + HistogramBase::Inconsistency problem) override; + virtual void InconsistencyDetectedInLoggedCount(int amount) override; // Calculates deltas in histogram counters. HistogramSnapshotManager histogram_snapshot_manager_; diff --git a/base/metrics/histogram_samples.cc b/base/metrics/histogram_samples.cc index 2319ed1..26c2aeb 100644 --- a/base/metrics/histogram_samples.cc +++ b/base/metrics/histogram_samples.cc @@ -15,11 +15,11 @@ class SampleCountPickleIterator : public SampleCountIterator { public: explicit SampleCountPickleIterator(PickleIterator* iter); - virtual bool Done() const OVERRIDE; - virtual void Next() OVERRIDE; + virtual bool Done() const override; + virtual void Next() override; virtual void Get(HistogramBase::Sample* min, HistogramBase::Sample* max, - HistogramBase::Count* count) const OVERRIDE; + HistogramBase::Count* count) const override; private: PickleIterator* const iter_; diff --git a/base/metrics/histogram_snapshot_manager_unittest.cc b/base/metrics/histogram_snapshot_manager_unittest.cc index e6672ea..2da22be 100644 --- a/base/metrics/histogram_snapshot_manager_unittest.cc +++ b/base/metrics/histogram_snapshot_manager_unittest.cc @@ -19,21 +19,21 @@ class HistogramFlattenerDeltaRecorder : public HistogramFlattener { HistogramFlattenerDeltaRecorder() {} virtual void RecordDelta(const HistogramBase& histogram, - const HistogramSamples& snapshot) OVERRIDE { + const HistogramSamples& snapshot) override { recorded_delta_histogram_names_.push_back(histogram.histogram_name()); } virtual void InconsistencyDetected( - HistogramBase::Inconsistency problem) OVERRIDE { + HistogramBase::Inconsistency problem) override { ASSERT_TRUE(false); } virtual void UniqueInconsistencyDetected( - HistogramBase::Inconsistency problem) OVERRIDE { + HistogramBase::Inconsistency problem) override { ASSERT_TRUE(false); } - virtual void InconsistencyDetectedInLoggedCount(int amount) OVERRIDE { + virtual void InconsistencyDetectedInLoggedCount(int amount) override { ASSERT_TRUE(false); } diff --git a/base/metrics/sample_map.h b/base/metrics/sample_map.h index cdd1138..0972acd 100644 --- a/base/metrics/sample_map.h +++ b/base/metrics/sample_map.h @@ -24,16 +24,16 @@ class BASE_EXPORT_PRIVATE SampleMap : public HistogramSamples { // HistogramSamples implementation: virtual void Accumulate(HistogramBase::Sample value, - HistogramBase::Count count) OVERRIDE; + HistogramBase::Count count) override; virtual HistogramBase::Count GetCount( - HistogramBase::Sample value) const OVERRIDE; - virtual HistogramBase::Count TotalCount() const OVERRIDE; - virtual scoped_ptr<SampleCountIterator> Iterator() const OVERRIDE; + HistogramBase::Sample value) const override; + virtual HistogramBase::Count TotalCount() const override; + virtual scoped_ptr<SampleCountIterator> Iterator() const override; protected: virtual bool AddSubtractImpl( SampleCountIterator* iter, - HistogramSamples::Operator op) OVERRIDE; // |op| is ADD or SUBTRACT. + HistogramSamples::Operator op) override; // |op| is ADD or SUBTRACT. private: std::map<HistogramBase::Sample, HistogramBase::Count> sample_counts_; @@ -50,11 +50,11 @@ class BASE_EXPORT_PRIVATE SampleMapIterator : public SampleCountIterator { virtual ~SampleMapIterator(); // SampleCountIterator implementation: - virtual bool Done() const OVERRIDE; - virtual void Next() OVERRIDE; + virtual bool Done() const override; + virtual void Next() override; virtual void Get(HistogramBase::Sample* min, HistogramBase::Sample* max, - HistogramBase::Count* count) const OVERRIDE; + HistogramBase::Count* count) const override; private: SampleToCountMap::const_iterator iter_; const SampleToCountMap::const_iterator end_; diff --git a/base/metrics/sample_vector.h b/base/metrics/sample_vector.h index 6b2adcf..8cc8ce9 100644 --- a/base/metrics/sample_vector.h +++ b/base/metrics/sample_vector.h @@ -27,11 +27,11 @@ class BASE_EXPORT_PRIVATE SampleVector : public HistogramSamples { // HistogramSamples implementation: virtual void Accumulate(HistogramBase::Sample value, - HistogramBase::Count count) OVERRIDE; + HistogramBase::Count count) override; virtual HistogramBase::Count GetCount( - HistogramBase::Sample value) const OVERRIDE; - virtual HistogramBase::Count TotalCount() const OVERRIDE; - virtual scoped_ptr<SampleCountIterator> Iterator() const OVERRIDE; + HistogramBase::Sample value) const override; + virtual HistogramBase::Count TotalCount() const override; + virtual scoped_ptr<SampleCountIterator> Iterator() const override; // Get count of a specific bucket. HistogramBase::Count GetCountAtIndex(size_t bucket_index) const; @@ -39,7 +39,7 @@ class BASE_EXPORT_PRIVATE SampleVector : public HistogramSamples { protected: virtual bool AddSubtractImpl( SampleCountIterator* iter, - HistogramSamples::Operator op) OVERRIDE; // |op| is ADD or SUBTRACT. + HistogramSamples::Operator op) override; // |op| is ADD or SUBTRACT. virtual size_t GetBucketIndex(HistogramBase::Sample value) const; @@ -61,14 +61,14 @@ class BASE_EXPORT_PRIVATE SampleVectorIterator : public SampleCountIterator { virtual ~SampleVectorIterator(); // SampleCountIterator implementation: - virtual bool Done() const OVERRIDE; - virtual void Next() OVERRIDE; + virtual bool Done() const override; + virtual void Next() override; virtual void Get(HistogramBase::Sample* min, HistogramBase::Sample* max, - HistogramBase::Count* count) const OVERRIDE; + HistogramBase::Count* count) const override; // SampleVector uses predefined buckets, so iterator can return bucket index. - virtual bool GetBucketIndex(size_t* index) const OVERRIDE; + virtual bool GetBucketIndex(size_t* index) const override; private: void SkipEmptyBuckets(); diff --git a/base/metrics/sparse_histogram.h b/base/metrics/sparse_histogram.h index c114916..321c630 100644 --- a/base/metrics/sparse_histogram.h +++ b/base/metrics/sparse_histogram.h @@ -37,21 +37,21 @@ class BASE_EXPORT_PRIVATE SparseHistogram : public HistogramBase { virtual ~SparseHistogram(); // HistogramBase implementation: - virtual HistogramType GetHistogramType() const OVERRIDE; + virtual HistogramType GetHistogramType() const override; virtual bool HasConstructionArguments( Sample expected_minimum, Sample expected_maximum, - size_t expected_bucket_count) const OVERRIDE; - virtual void Add(Sample value) OVERRIDE; - virtual void AddSamples(const HistogramSamples& samples) OVERRIDE; - virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE; - virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE; - virtual void WriteHTMLGraph(std::string* output) const OVERRIDE; - virtual void WriteAscii(std::string* output) const OVERRIDE; + size_t expected_bucket_count) const override; + virtual void Add(Sample value) override; + virtual void AddSamples(const HistogramSamples& samples) override; + virtual bool AddSamplesFromPickle(PickleIterator* iter) override; + virtual scoped_ptr<HistogramSamples> SnapshotSamples() const override; + virtual void WriteHTMLGraph(std::string* output) const override; + virtual void WriteAscii(std::string* output) const override; protected: // HistogramBase implementation: - virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE; + virtual bool SerializeInfoImpl(Pickle* pickle) const override; private: // Clients should always use FactoryGet to create SparseHistogram. @@ -61,10 +61,10 @@ class BASE_EXPORT_PRIVATE SparseHistogram : public HistogramBase { PickleIterator* iter); static HistogramBase* DeserializeInfoImpl(PickleIterator* iter); - virtual void GetParameters(DictionaryValue* params) const OVERRIDE; + virtual void GetParameters(DictionaryValue* params) const override; virtual void GetCountAndBucketData(Count* count, int64* sum, - ListValue* buckets) const OVERRIDE; + ListValue* buckets) const override; // Helpers for emitting Ascii graphic. Each method appends data to output. void WriteAsciiImpl(bool graph_it, diff --git a/base/metrics/stats_counters.h b/base/metrics/stats_counters.h index d47bab3..a2c7dec 100644 --- a/base/metrics/stats_counters.h +++ b/base/metrics/stats_counters.h @@ -164,7 +164,7 @@ class BASE_EXPORT StatsRate : public StatsCounterTimer { explicit StatsRate(const std::string& name); virtual ~StatsRate(); - virtual void Add(int value) OVERRIDE; + virtual void Add(int value) override; private: StatsCounter counter_; diff --git a/base/metrics/stats_table_unittest.cc b/base/metrics/stats_table_unittest.cc index 840f926..501cbc7 100644 --- a/base/metrics/stats_table_unittest.cc +++ b/base/metrics/stats_table_unittest.cc @@ -70,7 +70,7 @@ class StatsTableThread : public SimpleThread { : SimpleThread(name), id_(id) {} - virtual void Run() OVERRIDE; + virtual void Run() override; private: int id_; diff --git a/base/observer_list_unittest.cc b/base/observer_list_unittest.cc index 1bda3dc..3df8db0 100644 --- a/base/observer_list_unittest.cc +++ b/base/observer_list_unittest.cc @@ -26,7 +26,7 @@ class Foo { class Adder : public Foo { public: explicit Adder(int scaler) : total(0), scaler_(scaler) {} - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { total += x * scaler_; } virtual ~Adder() {} @@ -43,7 +43,7 @@ class Disrupter : public Foo { doomed_(doomed) { } virtual ~Disrupter() {} - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { list_->RemoveObserver(doomed_); } @@ -59,7 +59,7 @@ class ThreadSafeDisrupter : public Foo { doomed_(doomed) { } virtual ~ThreadSafeDisrupter() {} - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { list_->RemoveObserver(doomed_); } @@ -77,7 +77,7 @@ class AddInObserve : public Foo { adder(1) { } - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { if (!added) { added = true; observer_list->AddObserver(&adder); @@ -112,7 +112,7 @@ class AddRemoveThread : public PlatformThread::Delegate, virtual ~AddRemoveThread() { } - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { loop_ = new MessageLoop(); // Fire up a message loop. loop_->PostTask( FROM_HERE, @@ -153,7 +153,7 @@ class AddRemoveThread : public PlatformThread::Delegate, loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); } - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { count_observes_++; // If we're getting called after we removed ourselves from @@ -329,7 +329,7 @@ class FooRemover : public Foo { foos_.push_back(foo); } - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { std::vector<Foo*> tmp; tmp.swap(foos_); for (std::vector<Foo*>::iterator it = tmp.begin(); @@ -481,7 +481,7 @@ class AddInClearObserve : public Foo { explicit AddInClearObserve(ObserverList<Foo>* list) : list_(list), added_(false), adder_(1) {} - virtual void Observe(int /* x */) OVERRIDE { + virtual void Observe(int /* x */) override { list_->Clear(); list_->AddObserver(&adder_); added_ = true; @@ -526,7 +526,7 @@ class ListDestructor : public Foo { explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {} virtual ~ListDestructor() {} - virtual void Observe(int x) OVERRIDE { + virtual void Observe(int x) override { delete list_; } diff --git a/base/posix/file_descriptor_shuffle.h b/base/posix/file_descriptor_shuffle.h index 5fa590b..875fdf5 100644 --- a/base/posix/file_descriptor_shuffle.h +++ b/base/posix/file_descriptor_shuffle.h @@ -48,9 +48,9 @@ class InjectionDelegate { // An implementation of the InjectionDelegate interface using the file // descriptor table of the current process as the domain. class BASE_EXPORT FileDescriptorTableInjection : public InjectionDelegate { - virtual bool Duplicate(int* result, int fd) OVERRIDE; - virtual bool Move(int src, int dest) OVERRIDE; - virtual void Close(int fd) OVERRIDE; + virtual bool Duplicate(int* result, int fd) override; + virtual bool Move(int src, int dest) override; + virtual void Close(int fd) override; }; // A single arc of the directed graph which describes an injective multimapping. diff --git a/base/posix/file_descriptor_shuffle_unittest.cc b/base/posix/file_descriptor_shuffle_unittest.cc index 9e1b2500..b12c909 100644 --- a/base/posix/file_descriptor_shuffle_unittest.cc +++ b/base/posix/file_descriptor_shuffle_unittest.cc @@ -44,18 +44,18 @@ class InjectionTracer : public InjectionDelegate { : next_duplicate_(kDuplicateBase) { } - virtual bool Duplicate(int* result, int fd) OVERRIDE { + virtual bool Duplicate(int* result, int fd) override { *result = next_duplicate_++; actions_.push_back(Action(Action::DUPLICATE, *result, fd)); return true; } - virtual bool Move(int src, int dest) OVERRIDE { + virtual bool Move(int src, int dest) override { actions_.push_back(Action(Action::MOVE, src, dest)); return true; } - virtual void Close(int fd) OVERRIDE { + virtual void Close(int fd) override { actions_.push_back(Action(Action::CLOSE, fd)); } @@ -250,15 +250,15 @@ TEST(FileDescriptorShuffleTest, FanoutAndClose3) { class FailingDelegate : public InjectionDelegate { public: - virtual bool Duplicate(int* result, int fd) OVERRIDE { + virtual bool Duplicate(int* result, int fd) override { return false; } - virtual bool Move(int src, int dest) OVERRIDE { + virtual bool Move(int src, int dest) override { return false; } - virtual void Close(int fd) OVERRIDE {} + virtual void Close(int fd) override {} }; TEST(FileDescriptorShuffleTest, EmptyWithFailure) { diff --git a/base/power_monitor/power_monitor_device_source.h b/base/power_monitor/power_monitor_device_source.h index d29ec0a..3d264b4 100644 --- a/base/power_monitor/power_monitor_device_source.h +++ b/base/power_monitor/power_monitor_device_source.h @@ -90,7 +90,7 @@ class BASE_EXPORT PowerMonitorDeviceSource : public PowerMonitorSource { // Platform-specific method to check whether the system is currently // running on battery power. Returns true if running on batteries, // false otherwise. - virtual bool IsOnBatteryPowerImpl() OVERRIDE; + virtual bool IsOnBatteryPowerImpl() override; // Checks the battery status and notifies observers if the battery // status has changed. diff --git a/base/prefs/default_pref_store.h b/base/prefs/default_pref_store.h index 23b9096..9939876 100644 --- a/base/prefs/default_pref_store.h +++ b/base/prefs/default_pref_store.h @@ -22,10 +22,10 @@ class BASE_PREFS_EXPORT DefaultPrefStore : public PrefStore { // PrefStore implementation: virtual bool GetValue(const std::string& key, - const base::Value** result) const OVERRIDE; - virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE; - virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE; - virtual bool HasObservers() const OVERRIDE; + const base::Value** result) const override; + virtual void AddObserver(PrefStore::Observer* observer) override; + virtual void RemoveObserver(PrefStore::Observer* observer) override; + virtual bool HasObservers() const override; // Sets a |value| for |key|. Should only be called if a value has not been // set yet; otherwise call ReplaceDefaultValue(). diff --git a/base/prefs/default_pref_store_unittest.cc b/base/prefs/default_pref_store_unittest.cc index 7181989..3f28132 100644 --- a/base/prefs/default_pref_store_unittest.cc +++ b/base/prefs/default_pref_store_unittest.cc @@ -20,8 +20,8 @@ class MockPrefStoreObserver : public PrefStore::Observer { } // PrefStore::Observer implementation: - virtual void OnPrefValueChanged(const std::string& key) OVERRIDE; - virtual void OnInitializationCompleted(bool succeeded) OVERRIDE {} + virtual void OnPrefValueChanged(const std::string& key) override; + virtual void OnInitializationCompleted(bool succeeded) override {} private: DefaultPrefStore* pref_store_; diff --git a/base/prefs/json_pref_store.h b/base/prefs/json_pref_store.h index 7f26c89..b6d0b19 100644 --- a/base/prefs/json_pref_store.h +++ b/base/prefs/json_pref_store.h @@ -67,28 +67,28 @@ class BASE_PREFS_EXPORT JsonPrefStore // PrefStore overrides: virtual bool GetValue(const std::string& key, - const base::Value** result) const OVERRIDE; - virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE; - virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE; - virtual bool HasObservers() const OVERRIDE; - virtual bool IsInitializationComplete() const OVERRIDE; + const base::Value** result) const override; + virtual void AddObserver(PrefStore::Observer* observer) override; + virtual void RemoveObserver(PrefStore::Observer* observer) override; + virtual bool HasObservers() const override; + virtual bool IsInitializationComplete() const override; // PersistentPrefStore overrides: virtual bool GetMutableValue(const std::string& key, - base::Value** result) OVERRIDE; - virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE; + base::Value** result) override; + virtual void SetValue(const std::string& key, base::Value* value) override; virtual void SetValueSilently(const std::string& key, - base::Value* value) OVERRIDE; - virtual void RemoveValue(const std::string& key) OVERRIDE; - virtual bool ReadOnly() const OVERRIDE; - virtual PrefReadError GetReadError() const OVERRIDE; + base::Value* value) override; + virtual void RemoveValue(const std::string& key) override; + virtual bool ReadOnly() const override; + virtual PrefReadError GetReadError() const override; // Note this method may be asynchronous if this instance has a |pref_filter_| // in which case it will return PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE. // See details in pref_filter.h. - virtual PrefReadError ReadPrefs() OVERRIDE; - virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE; - virtual void CommitPendingWrite() OVERRIDE; - virtual void ReportValueChanged(const std::string& key) OVERRIDE; + virtual PrefReadError ReadPrefs() override; + virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) override; + virtual void CommitPendingWrite() override; + virtual void ReportValueChanged(const std::string& key) override; // Just like RemoveValue(), but doesn't notify observers. Used when doing some // cleanup that shouldn't otherwise alert observers. @@ -111,7 +111,7 @@ class BASE_PREFS_EXPORT JsonPrefStore void OnFileRead(scoped_ptr<ReadResult> read_result); // ImportantFileWriter::DataSerializer overrides: - virtual bool SerializeData(std::string* output) OVERRIDE; + virtual bool SerializeData(std::string* output) override; // This method is called after the JSON file has been read and the result has // potentially been intercepted and modified by |pref_filter_|. diff --git a/base/prefs/json_pref_store_unittest.cc b/base/prefs/json_pref_store_unittest.cc index d09d9d3..437f337 100644 --- a/base/prefs/json_pref_store_unittest.cc +++ b/base/prefs/json_pref_store_unittest.cc @@ -37,10 +37,10 @@ class InterceptingPrefFilter : public PrefFilter { // PrefFilter implementation: virtual void FilterOnLoad( const PostFilterOnLoadCallback& post_filter_on_load_callback, - scoped_ptr<base::DictionaryValue> pref_store_contents) OVERRIDE; - virtual void FilterUpdate(const std::string& path) OVERRIDE {} + scoped_ptr<base::DictionaryValue> pref_store_contents) override; + virtual void FilterUpdate(const std::string& path) override {} virtual void FilterSerializeData( - base::DictionaryValue* pref_store_contents) OVERRIDE {} + base::DictionaryValue* pref_store_contents) override {} bool has_intercepted_prefs() const { return intercepted_prefs_ != NULL; } @@ -86,7 +86,7 @@ class MockReadErrorDelegate : public PersistentPrefStore::ReadErrorDelegate { class JsonPrefStoreTest : public testing::Test { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir_)); @@ -94,7 +94,7 @@ class JsonPrefStoreTest : public testing::Test { ASSERT_TRUE(PathExists(data_dir_)); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { // Make sure all pending tasks have been processed (e.g., deleting the // JsonPrefStore may post write tasks). message_loop_.PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure()); diff --git a/base/prefs/overlay_user_pref_store.h b/base/prefs/overlay_user_pref_store.h index c9993b9..0e78230 100644 --- a/base/prefs/overlay_user_pref_store.h +++ b/base/prefs/overlay_user_pref_store.h @@ -30,30 +30,30 @@ class BASE_PREFS_EXPORT OverlayUserPrefStore : public PersistentPrefStore, virtual bool IsSetInOverlay(const std::string& key) const; // Methods of PrefStore. - virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE; - virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE; - virtual bool HasObservers() const OVERRIDE; - virtual bool IsInitializationComplete() const OVERRIDE; + virtual void AddObserver(PrefStore::Observer* observer) override; + virtual void RemoveObserver(PrefStore::Observer* observer) override; + virtual bool HasObservers() const override; + virtual bool IsInitializationComplete() const override; virtual bool GetValue(const std::string& key, - const base::Value** result) const OVERRIDE; + const base::Value** result) const override; // Methods of PersistentPrefStore. virtual bool GetMutableValue(const std::string& key, - base::Value** result) OVERRIDE; - virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE; + base::Value** result) override; + virtual void SetValue(const std::string& key, base::Value* value) override; virtual void SetValueSilently(const std::string& key, - base::Value* value) OVERRIDE; - virtual void RemoveValue(const std::string& key) OVERRIDE; - virtual bool ReadOnly() const OVERRIDE; - virtual PrefReadError GetReadError() const OVERRIDE; - virtual PrefReadError ReadPrefs() OVERRIDE; - virtual void ReadPrefsAsync(ReadErrorDelegate* delegate) OVERRIDE; - virtual void CommitPendingWrite() OVERRIDE; - virtual void ReportValueChanged(const std::string& key) OVERRIDE; + base::Value* value) override; + virtual void RemoveValue(const std::string& key) override; + virtual bool ReadOnly() const override; + virtual PrefReadError GetReadError() const override; + virtual PrefReadError ReadPrefs() override; + virtual void ReadPrefsAsync(ReadErrorDelegate* delegate) override; + virtual void CommitPendingWrite() override; + virtual void ReportValueChanged(const std::string& key) override; // Methods of PrefStore::Observer. - virtual void OnPrefValueChanged(const std::string& key) OVERRIDE; - virtual void OnInitializationCompleted(bool succeeded) OVERRIDE; + virtual void OnPrefValueChanged(const std::string& key) override; + virtual void OnInitializationCompleted(bool succeeded) override; void RegisterOverlayPref(const std::string& key); void RegisterOverlayPref(const std::string& overlay_key, diff --git a/base/prefs/pref_change_registrar.h b/base/prefs/pref_change_registrar.h index a914bea..693d3e7 100644 --- a/base/prefs/pref_change_registrar.h +++ b/base/prefs/pref_change_registrar.h @@ -65,7 +65,7 @@ class BASE_PREFS_EXPORT PrefChangeRegistrar : public PrefObserver { private: // PrefObserver: virtual void OnPreferenceChanged(PrefService* service, - const std::string& pref_name) OVERRIDE; + const std::string& pref_name) override; static void InvokeUnnamedCallback(const base::Closure& callback, const std::string& pref_name); diff --git a/base/prefs/pref_change_registrar_unittest.cc b/base/prefs/pref_change_registrar_unittest.cc index f353a8f..e9255a0 100644 --- a/base/prefs/pref_change_registrar_unittest.cc +++ b/base/prefs/pref_change_registrar_unittest.cc @@ -41,7 +41,7 @@ class PrefChangeRegistrarTest : public testing::Test { virtual ~PrefChangeRegistrarTest() {} protected: - virtual void SetUp() OVERRIDE; + virtual void SetUp() override; base::Closure observer() const { return base::Bind(&base::DoNothing); diff --git a/base/prefs/pref_member.h b/base/prefs/pref_member.h index 2c3445d..fc27793 100644 --- a/base/prefs/pref_member.h +++ b/base/prefs/pref_member.h @@ -117,7 +117,7 @@ class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver { // PrefObserver virtual void OnPreferenceChanged(PrefService* service, - const std::string& pref_name) OVERRIDE; + const std::string& pref_name) override; void VerifyValuePrefName() const { DCHECK(!pref_name_.empty()); @@ -264,7 +264,7 @@ class PrefMember : public subtle::PrefMemberBase { virtual ~Internal() {} virtual BASE_PREFS_EXPORT bool UpdateValueInternal( - const base::Value& value) const OVERRIDE; + const base::Value& value) const override; // We cache the value of the pref so we don't have to keep walking the pref // tree. @@ -273,8 +273,8 @@ class PrefMember : public subtle::PrefMemberBase { DISALLOW_COPY_AND_ASSIGN(Internal); }; - virtual Internal* internal() const OVERRIDE { return internal_.get(); } - virtual void CreateInternal() const OVERRIDE { internal_ = new Internal(); } + virtual Internal* internal() const override { return internal_.get(); } + virtual void CreateInternal() const override { internal_ = new Internal(); } // This method is used to do the actual sync with pref of the specified type. void BASE_PREFS_EXPORT UpdatePref(const ValueType& value); diff --git a/base/prefs/pref_notifier_impl.h b/base/prefs/pref_notifier_impl.h index 655203d..1aa243f 100644 --- a/base/prefs/pref_notifier_impl.h +++ b/base/prefs/pref_notifier_impl.h @@ -41,8 +41,8 @@ class BASE_PREFS_EXPORT PrefNotifierImpl protected: // PrefNotifier overrides. - virtual void OnPreferenceChanged(const std::string& pref_name) OVERRIDE; - virtual void OnInitializationCompleted(bool succeeded) OVERRIDE; + virtual void OnPreferenceChanged(const std::string& pref_name) override; + virtual void OnInitializationCompleted(bool succeeded) override; // A map from pref names to a list of observers. Observers get fired in the // order they are added. These should only be accessed externally for unit diff --git a/base/prefs/pref_service.cc b/base/prefs/pref_service.cc index 65605c5..bc86ac1 100644 --- a/base/prefs/pref_service.cc +++ b/base/prefs/pref_service.cc @@ -28,7 +28,7 @@ class ReadErrorHandler : public PersistentPrefStore::ReadErrorDelegate { ReadErrorHandler(base::Callback<void(PersistentPrefStore::PrefReadError)> cb) : callback_(cb) {} - virtual void OnError(PersistentPrefStore::PrefReadError error) OVERRIDE { + virtual void OnError(PersistentPrefStore::PrefReadError error) override { callback_.Run(error); } diff --git a/base/prefs/pref_store_observer_mock.h b/base/prefs/pref_store_observer_mock.h index 594807f..de7cc9d 100644 --- a/base/prefs/pref_store_observer_mock.h +++ b/base/prefs/pref_store_observer_mock.h @@ -21,8 +21,8 @@ class PrefStoreObserverMock : public PrefStore::Observer { void VerifyAndResetChangedKey(const std::string& expected); // PrefStore::Observer implementation - virtual void OnPrefValueChanged(const std::string& key) OVERRIDE; - virtual void OnInitializationCompleted(bool success) OVERRIDE; + virtual void OnPrefValueChanged(const std::string& key) override; + virtual void OnInitializationCompleted(bool success) override; std::vector<std::string> changed_keys; bool initialized; diff --git a/base/prefs/pref_value_store.h b/base/prefs/pref_value_store.h index 1c85ca7..a0409ef 100644 --- a/base/prefs/pref_value_store.h +++ b/base/prefs/pref_value_store.h @@ -161,8 +161,8 @@ class BASE_PREFS_EXPORT PrefValueStore { private: // PrefStore::Observer implementation. - virtual void OnPrefValueChanged(const std::string& key) OVERRIDE; - virtual void OnInitializationCompleted(bool succeeded) OVERRIDE; + virtual void OnPrefValueChanged(const std::string& key) override; + virtual void OnInitializationCompleted(bool succeeded) override; // PrefValueStore this keeper is part of. PrefValueStore* pref_value_store_; diff --git a/base/prefs/testing_pref_store.h b/base/prefs/testing_pref_store.h index 785f935..aa2bd80 100644 --- a/base/prefs/testing_pref_store.h +++ b/base/prefs/testing_pref_store.h @@ -22,25 +22,25 @@ class TestingPrefStore : public PersistentPrefStore { // Overriden from PrefStore. virtual bool GetValue(const std::string& key, - const base::Value** result) const OVERRIDE; - virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE; - virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE; - virtual bool HasObservers() const OVERRIDE; - virtual bool IsInitializationComplete() const OVERRIDE; + const base::Value** result) const override; + virtual void AddObserver(PrefStore::Observer* observer) override; + virtual void RemoveObserver(PrefStore::Observer* observer) override; + virtual bool HasObservers() const override; + virtual bool IsInitializationComplete() const override; // PersistentPrefStore overrides: virtual bool GetMutableValue(const std::string& key, - base::Value** result) OVERRIDE; - virtual void ReportValueChanged(const std::string& key) OVERRIDE; - virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE; + base::Value** result) override; + virtual void ReportValueChanged(const std::string& key) override; + virtual void SetValue(const std::string& key, base::Value* value) override; virtual void SetValueSilently(const std::string& key, - base::Value* value) OVERRIDE; - virtual void RemoveValue(const std::string& key) OVERRIDE; - virtual bool ReadOnly() const OVERRIDE; - virtual PrefReadError GetReadError() const OVERRIDE; - virtual PersistentPrefStore::PrefReadError ReadPrefs() OVERRIDE; - virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE; - virtual void CommitPendingWrite() OVERRIDE; + base::Value* value) override; + virtual void RemoveValue(const std::string& key) override; + virtual bool ReadOnly() const override; + virtual PrefReadError GetReadError() const override; + virtual PersistentPrefStore::PrefReadError ReadPrefs() override; + virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) override; + virtual void CommitPendingWrite() override; // Marks the store as having completed initialization. void SetInitializationCompleted(); diff --git a/base/prefs/value_map_pref_store.h b/base/prefs/value_map_pref_store.h index d4e41f45..d90d0c0 100644 --- a/base/prefs/value_map_pref_store.h +++ b/base/prefs/value_map_pref_store.h @@ -22,19 +22,19 @@ class BASE_PREFS_EXPORT ValueMapPrefStore : public WriteablePrefStore { // PrefStore overrides: virtual bool GetValue(const std::string& key, - const base::Value** value) const OVERRIDE; - virtual void AddObserver(PrefStore::Observer* observer) OVERRIDE; - virtual void RemoveObserver(PrefStore::Observer* observer) OVERRIDE; - virtual bool HasObservers() const OVERRIDE; + const base::Value** value) const override; + virtual void AddObserver(PrefStore::Observer* observer) override; + virtual void RemoveObserver(PrefStore::Observer* observer) override; + virtual bool HasObservers() const override; // WriteablePrefStore overrides: - virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE; - virtual void RemoveValue(const std::string& key) OVERRIDE; + virtual void SetValue(const std::string& key, base::Value* value) override; + virtual void RemoveValue(const std::string& key) override; virtual bool GetMutableValue(const std::string& key, - base::Value** value) OVERRIDE; - virtual void ReportValueChanged(const std::string& key) OVERRIDE; + base::Value** value) override; + virtual void ReportValueChanged(const std::string& key) override; virtual void SetValueSilently(const std::string& key, - base::Value* value) OVERRIDE; + base::Value* value) override; protected: virtual ~ValueMapPrefStore(); diff --git a/base/process/kill_posix.cc b/base/process/kill_posix.cc index adc1db3..d4ca726 100644 --- a/base/process/kill_posix.cc +++ b/base/process/kill_posix.cc @@ -410,7 +410,7 @@ class BackgroundReaper : public PlatformThread::Delegate { } // Overridden from PlatformThread::Delegate: - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { WaitForChildToDie(); delete this; } diff --git a/base/process/memory_unittest.cc b/base/process/memory_unittest.cc index 21b5a5bf..afbf5c6 100644 --- a/base/process/memory_unittest.cc +++ b/base/process/memory_unittest.cc @@ -182,11 +182,11 @@ class OutOfMemoryTest : public testing::Test { } #if defined(USE_TCMALLOC) - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { tc_set_new_mode(1); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { tc_set_new_mode(0); } #endif // defined(USE_TCMALLOC) diff --git a/base/process/process_iterator.h b/base/process/process_iterator.h index aa2fc41..185965a 100644 --- a/base/process/process_iterator.h +++ b/base/process/process_iterator.h @@ -166,7 +166,7 @@ class BASE_EXPORT NamedProcessIterator : public ProcessIterator { virtual ~NamedProcessIterator(); protected: - virtual bool IncludeEntry() OVERRIDE; + virtual bool IncludeEntry() override; private: FilePath::StringType executable_name_; diff --git a/base/sequence_checker_unittest.cc b/base/sequence_checker_unittest.cc index b818640..ad77db0 100644 --- a/base/sequence_checker_unittest.cc +++ b/base/sequence_checker_unittest.cc @@ -58,12 +58,12 @@ class SequenceCheckerTest : public testing::Test { virtual ~SequenceCheckerTest() {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { other_thread_.Start(); ResetPool(); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { other_thread_.Stop(); pool()->Shutdown(); } diff --git a/base/sync_socket.h b/base/sync_socket.h index 9923591..b8d947e 100644 --- a/base/sync_socket.h +++ b/base/sync_socket.h @@ -124,11 +124,11 @@ class BASE_EXPORT CancelableSyncSocket : public SyncSocket { // and there isn't a way to cancel a blocking synchronous Read that is // supported on <Vista. So, for Windows only, we override these // SyncSocket methods in order to support shutting down the 'socket'. - virtual bool Close() OVERRIDE; - virtual size_t Receive(void* buffer, size_t length) OVERRIDE; + virtual bool Close() override; + virtual size_t Receive(void* buffer, size_t length) override; virtual size_t ReceiveWithTimeout(void* buffer, size_t length, - TimeDelta timeout) OVERRIDE; + TimeDelta timeout) override; #endif // Send() is overridden to catch cases where the remote end is not responding @@ -136,7 +136,7 @@ class BASE_EXPORT CancelableSyncSocket : public SyncSocket { // implementation of Send() will not block indefinitely as // SyncSocket::Send will, but instead return 0, as no bytes could be sent. // Note that the socket will not be closed in this case. - virtual size_t Send(const void* buffer, size_t length) OVERRIDE; + virtual size_t Send(const void* buffer, size_t length) override; private: #if defined(OS_WIN) diff --git a/base/sync_socket_unittest.cc b/base/sync_socket_unittest.cc index 7e4089c..ddd2fcc 100644 --- a/base/sync_socket_unittest.cc +++ b/base/sync_socket_unittest.cc @@ -22,7 +22,7 @@ class HangingReceiveThread : public base::DelegateSimpleThread::Delegate { virtual ~HangingReceiveThread() {} - virtual void Run() OVERRIDE { + virtual void Run() override { int data = 0; ASSERT_EQ(socket_->Peek(), 0u); diff --git a/base/synchronization/condition_variable_unittest.cc b/base/synchronization/condition_variable_unittest.cc index 5f947a9..4232734 100644 --- a/base/synchronization/condition_variable_unittest.cc +++ b/base/synchronization/condition_variable_unittest.cc @@ -67,7 +67,7 @@ class WorkQueue : public PlatformThread::Delegate { virtual ~WorkQueue(); // PlatformThread::Delegate interface. - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; //---------------------------------------------------------------------------- // Worker threads only call the following methods. diff --git a/base/synchronization/condition_variable_win.cc b/base/synchronization/condition_variable_win.cc index 377fc9d..6dc4831 100644 --- a/base/synchronization/condition_variable_win.cc +++ b/base/synchronization/condition_variable_win.cc @@ -74,10 +74,10 @@ class WinVistaCondVar: public ConditionVarImpl { WinVistaCondVar(Lock* user_lock); ~WinVistaCondVar() {}; // Overridden from ConditionVarImpl. - virtual void Wait() OVERRIDE; - virtual void TimedWait(const TimeDelta& max_time) OVERRIDE; - virtual void Broadcast() OVERRIDE; - virtual void Signal() OVERRIDE; + virtual void Wait() override; + virtual void TimedWait(const TimeDelta& max_time) override; + virtual void Broadcast() override; + virtual void Signal() override; private: base::Lock& user_lock_; @@ -129,10 +129,10 @@ class WinXPCondVar : public ConditionVarImpl { WinXPCondVar(Lock* user_lock); ~WinXPCondVar(); // Overridden from ConditionVarImpl. - virtual void Wait() OVERRIDE; - virtual void TimedWait(const TimeDelta& max_time) OVERRIDE; - virtual void Broadcast() OVERRIDE; - virtual void Signal() OVERRIDE; + virtual void Wait() override; + virtual void TimedWait(const TimeDelta& max_time) override; + virtual void Broadcast() override; + virtual void Signal() override; // Define Event class that is used to form circularly linked lists. // The list container is an element with NULL as its handle_ value. diff --git a/base/synchronization/lock_unittest.cc b/base/synchronization/lock_unittest.cc index 16144755..60f4250 100644 --- a/base/synchronization/lock_unittest.cc +++ b/base/synchronization/lock_unittest.cc @@ -18,7 +18,7 @@ class BasicLockTestThread : public PlatformThread::Delegate { public: explicit BasicLockTestThread(Lock* lock) : lock_(lock), acquired_(0) {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { for (int i = 0; i < 10; i++) { lock_->Acquire(); acquired_++; @@ -93,7 +93,7 @@ class TryLockTestThread : public PlatformThread::Delegate { public: explicit TryLockTestThread(Lock* lock) : lock_(lock), got_lock_(false) {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { got_lock_ = lock_->Try(); if (got_lock_) lock_->Release(); @@ -162,7 +162,7 @@ class MutexLockTestThread : public PlatformThread::Delegate { } } - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { DoStuff(lock_, value_); } diff --git a/base/synchronization/waitable_event_posix.cc b/base/synchronization/waitable_event_posix.cc index 89f42ff..f34b2a4 100644 --- a/base/synchronization/waitable_event_posix.cc +++ b/base/synchronization/waitable_event_posix.cc @@ -91,7 +91,7 @@ class SyncWaiter : public WaitableEvent::Waiter { cv_(&lock_) { } - virtual bool Fire(WaitableEvent* signaling_event) OVERRIDE { + virtual bool Fire(WaitableEvent* signaling_event) override { base::AutoLock locked(lock_); if (fired_) @@ -117,7 +117,7 @@ class SyncWaiter : public WaitableEvent::Waiter { // These waiters are always stack allocated and don't delete themselves. Thus // there's no problem and the ABA tag is the same as the object pointer. // --------------------------------------------------------------------------- - virtual bool Compare(void* tag) OVERRIDE { + virtual bool Compare(void* tag) override { return this == tag; } diff --git a/base/synchronization/waitable_event_unittest.cc b/base/synchronization/waitable_event_unittest.cc index 0b50d81..a8913fd 100644 --- a/base/synchronization/waitable_event_unittest.cc +++ b/base/synchronization/waitable_event_unittest.cc @@ -78,7 +78,7 @@ class WaitableEventSignaler : public PlatformThread::Delegate { ev_(ev) { } - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { PlatformThread::Sleep(TimeDelta::FromSecondsD(seconds_)); ev_->Signal(); } diff --git a/base/synchronization/waitable_event_watcher.h b/base/synchronization/waitable_event_watcher.h index ede2835..4d2f9b5 100644 --- a/base/synchronization/waitable_event_watcher.h +++ b/base/synchronization/waitable_event_watcher.h @@ -92,11 +92,11 @@ class BASE_EXPORT WaitableEventWatcher private: #if defined(OS_WIN) - virtual void OnObjectSignaled(HANDLE h) OVERRIDE; + virtual void OnObjectSignaled(HANDLE h) override; win::ObjectWatcher watcher_; #else // Implementation of MessageLoop::DestructionObserver - virtual void WillDestroyCurrentMessageLoop() OVERRIDE; + virtual void WillDestroyCurrentMessageLoop() override; MessageLoop* message_loop_; scoped_refptr<Flag> cancel_flag_; diff --git a/base/synchronization/waitable_event_watcher_posix.cc b/base/synchronization/waitable_event_watcher_posix.cc index 54e01f8..e791871 100644 --- a/base/synchronization/waitable_event_watcher_posix.cc +++ b/base/synchronization/waitable_event_watcher_posix.cc @@ -65,7 +65,7 @@ class AsyncWaiter : public WaitableEvent::Waiter { callback_(callback), flag_(flag) { } - virtual bool Fire(WaitableEvent* event) OVERRIDE { + virtual bool Fire(WaitableEvent* event) override { // Post the callback if we haven't been cancelled. if (!flag_->value()) { message_loop_->PostTask(FROM_HERE, callback_); @@ -81,7 +81,7 @@ class AsyncWaiter : public WaitableEvent::Waiter { } // See StopWatching for discussion - virtual bool Compare(void* tag) OVERRIDE { + virtual bool Compare(void* tag) override { return tag == flag_.get(); } diff --git a/base/task_runner.cc b/base/task_runner.cc index 5860f28..f2c64f3 100644 --- a/base/task_runner.cc +++ b/base/task_runner.cc @@ -21,7 +21,7 @@ class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl { private: virtual bool PostTask(const tracked_objects::Location& from_here, - const Closure& task) OVERRIDE; + const Closure& task) override; // Non-owning. TaskRunner* destination_; diff --git a/base/test/expectations/parser_unittest.cc b/base/test/expectations/parser_unittest.cc index 1c55a05..a456458 100644 --- a/base/test/expectations/parser_unittest.cc +++ b/base/test/expectations/parser_unittest.cc @@ -16,15 +16,15 @@ class TestExpectationParserTest : public testing::Test, public Parser::Delegate { public: virtual void EmitExpectation( - const test_expectations::Expectation& expectation) OVERRIDE { + const test_expectations::Expectation& expectation) override { expectations_.push_back(expectation); } - virtual void OnSyntaxError(const std::string& message) OVERRIDE { + virtual void OnSyntaxError(const std::string& message) override { syntax_error_ = message; } - virtual void OnDataError(const std::string& error) OVERRIDE { + virtual void OnDataError(const std::string& error) override { data_errors_.push_back(error); } diff --git a/base/test/gtest_xml_util.h b/base/test/gtest_xml_util.h index 79527e5..f832cde 100644 --- a/base/test/gtest_xml_util.h +++ b/base/test/gtest_xml_util.h @@ -28,10 +28,10 @@ class XmlUnitTestResultPrinter : public testing::EmptyTestEventListener { private: // testing::EmptyTestEventListener: - virtual void OnTestCaseStart(const testing::TestCase& test_case) OVERRIDE; - virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE; - virtual void OnTestEnd(const testing::TestInfo& test_info) OVERRIDE; - virtual void OnTestCaseEnd(const testing::TestCase& test_case) OVERRIDE; + virtual void OnTestCaseStart(const testing::TestCase& test_case) override; + virtual void OnTestStart(const testing::TestInfo& test_info) override; + virtual void OnTestEnd(const testing::TestInfo& test_info) override; + virtual void OnTestCaseEnd(const testing::TestCase& test_case) override; FILE* output_file_; diff --git a/base/test/launcher/test_launcher.cc b/base/test/launcher/test_launcher.cc index 2a36c69..eab51f4 100644 --- a/base/test/launcher/test_launcher.cc +++ b/base/test/launcher/test_launcher.cc @@ -142,7 +142,7 @@ class SignalFDWatcher : public MessageLoopForIO::Watcher { SignalFDWatcher() { } - virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE { + virtual void OnFileCanReadWithoutBlocking(int fd) override { fprintf(stdout, "\nCaught signal. Killing spawned test processes...\n"); fflush(stdout); @@ -152,7 +152,7 @@ class SignalFDWatcher : public MessageLoopForIO::Watcher { exit(1); } - virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE { + virtual void OnFileCanWriteWithoutBlocking(int fd) override { NOTREACHED(); } diff --git a/base/test/launcher/unit_test_launcher.cc b/base/test/launcher/unit_test_launcher.cc index 0cbae2f..d6aeef8 100644 --- a/base/test/launcher/unit_test_launcher.cc +++ b/base/test/launcher/unit_test_launcher.cc @@ -119,7 +119,7 @@ class UnitTestLauncherDelegate : public TestLauncherDelegate { }; virtual bool ShouldRunTest(const testing::TestCase* test_case, - const testing::TestInfo* test_info) OVERRIDE { + const testing::TestInfo* test_info) override { DCHECK(thread_checker_.CalledOnValidThread()); // There is no additional logic to disable specific tests. @@ -127,7 +127,7 @@ class UnitTestLauncherDelegate : public TestLauncherDelegate { } virtual size_t RunTests(TestLauncher* test_launcher, - const std::vector<std::string>& test_names) OVERRIDE { + const std::vector<std::string>& test_names) override { DCHECK(thread_checker_.CalledOnValidThread()); std::vector<std::string> batch; @@ -147,7 +147,7 @@ class UnitTestLauncherDelegate : public TestLauncherDelegate { virtual size_t RetryTests( TestLauncher* test_launcher, - const std::vector<std::string>& test_names) OVERRIDE { + const std::vector<std::string>& test_names) override { MessageLoop::current()->PostTask( FROM_HERE, Bind(&UnitTestLauncherDelegate::RunSerially, diff --git a/base/test/null_task_runner.h b/base/test/null_task_runner.h index d6390e5..9515733 100644 --- a/base/test/null_task_runner.h +++ b/base/test/null_task_runner.h @@ -17,13 +17,13 @@ class NullTaskRunner : public base::SingleThreadTaskRunner { virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const base::Closure& task, - base::TimeDelta delay) OVERRIDE; + base::TimeDelta delay) override; virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const base::Closure& task, - base::TimeDelta delay) OVERRIDE; + base::TimeDelta delay) override; // Always returns true to avoid triggering DCHECKs. - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + virtual bool RunsTasksOnCurrentThread() const override; protected: virtual ~NullTaskRunner(); diff --git a/base/test/perf_test_suite.h b/base/test/perf_test_suite.h index 85bfc41..df8162b 100644 --- a/base/test/perf_test_suite.h +++ b/base/test/perf_test_suite.h @@ -13,8 +13,8 @@ class PerfTestSuite : public TestSuite { public: PerfTestSuite(int argc, char** argv); - virtual void Initialize() OVERRIDE; - virtual void Shutdown() OVERRIDE; + virtual void Initialize() override; + virtual void Shutdown() override; }; } // namespace base diff --git a/base/test/power_monitor_test_base.h b/base/test/power_monitor_test_base.h index 6e37f3d..4aaafb9 100644 --- a/base/test/power_monitor_test_base.h +++ b/base/test/power_monitor_test_base.h @@ -21,7 +21,7 @@ class PowerMonitorTestSource : public PowerMonitorSource { void GenerateResumeEvent(); protected: - virtual bool IsOnBatteryPowerImpl() OVERRIDE; + virtual bool IsOnBatteryPowerImpl() override; bool test_on_battery_power_; MessageLoop message_loop_; @@ -33,9 +33,9 @@ class PowerMonitorTestObserver : public PowerObserver { virtual ~PowerMonitorTestObserver(); // PowerObserver callbacks. - virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE; - virtual void OnSuspend() OVERRIDE; - virtual void OnResume() OVERRIDE; + virtual void OnPowerStateChange(bool on_battery_power) override; + virtual void OnSuspend() override; + virtual void OnResume() override; // Test status counts. bool last_power_state() { return last_power_state_; } diff --git a/base/test/sequenced_worker_pool_owner.h b/base/test/sequenced_worker_pool_owner.h index 1cc3fd6..f6f0bb2 100644 --- a/base/test/sequenced_worker_pool_owner.h +++ b/base/test/sequenced_worker_pool_owner.h @@ -42,9 +42,9 @@ class SequencedWorkerPoolOwner : public SequencedWorkerPool::TestingObserver { private: // SequencedWorkerPool::TestingObserver implementation. - virtual void OnHasWork() OVERRIDE; - virtual void WillWaitForShutdown() OVERRIDE; - virtual void OnDestruct() OVERRIDE; + virtual void OnHasWork() override; + virtual void WillWaitForShutdown() override; + virtual void OnDestruct() override; MessageLoop* const constructor_message_loop_; scoped_refptr<SequencedWorkerPool> pool_; diff --git a/base/test/simple_test_clock.h b/base/test/simple_test_clock.h index 2056aab..a49cc53 100644 --- a/base/test/simple_test_clock.h +++ b/base/test/simple_test_clock.h @@ -21,7 +21,7 @@ class SimpleTestClock : public Clock { SimpleTestClock(); virtual ~SimpleTestClock(); - virtual Time Now() OVERRIDE; + virtual Time Now() override; // Advances the clock by |delta|. void Advance(TimeDelta delta); diff --git a/base/test/simple_test_tick_clock.h b/base/test/simple_test_tick_clock.h index 867de80..c67eb55 100644 --- a/base/test/simple_test_tick_clock.h +++ b/base/test/simple_test_tick_clock.h @@ -21,7 +21,7 @@ class SimpleTestTickClock : public TickClock { SimpleTestTickClock(); virtual ~SimpleTestTickClock(); - virtual TimeTicks NowTicks() OVERRIDE; + virtual TimeTicks NowTicks() override; // Advances the clock by |delta|, which must not be negative. void Advance(TimeDelta delta); diff --git a/base/test/test_simple_task_runner.h b/base/test/test_simple_task_runner.h index af4f4eb..56a1894 100644 --- a/base/test/test_simple_task_runner.h +++ b/base/test/test_simple_task_runner.h @@ -49,13 +49,13 @@ class TestSimpleTaskRunner : public SingleThreadTaskRunner { // SingleThreadTaskRunner implementation. virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; + TimeDelta delay) override; virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; + TimeDelta delay) override; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + virtual bool RunsTasksOnCurrentThread() const override; const std::deque<TestPendingTask>& GetPendingTasks() const; bool HasPendingTask() const; diff --git a/base/test/test_suite.cc b/base/test/test_suite.cc index 45b02f9..23ffa1e 100644 --- a/base/test/test_suite.cc +++ b/base/test/test_suite.cc @@ -49,7 +49,7 @@ namespace { class MaybeTestDisabler : public testing::EmptyTestEventListener { public: - virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE { + virtual void OnTestStart(const testing::TestInfo& test_info) override { ASSERT_FALSE(TestSuite::IsMarkedMaybe(test_info)) << "Probably the OS #ifdefs don't include all of the necessary " "platforms.\nPlease ensure that no tests have the MAYBE_ prefix " @@ -63,11 +63,11 @@ class TestClientInitializer : public testing::EmptyTestEventListener { : old_command_line_(CommandLine::NO_PROGRAM) { } - virtual void OnTestStart(const testing::TestInfo& test_info) OVERRIDE { + virtual void OnTestStart(const testing::TestInfo& test_info) override { old_command_line_ = *CommandLine::ForCurrentProcess(); } - virtual void OnTestEnd(const testing::TestInfo& test_info) OVERRIDE { + virtual void OnTestEnd(const testing::TestInfo& test_info) override { *CommandLine::ForCurrentProcess() = old_command_line_; } diff --git a/base/test/test_support_android.cc b/base/test/test_support_android.cc index 4ada567..eeab9ee 100644 --- a/base/test/test_support_android.cc +++ b/base/test/test_support_android.cc @@ -74,12 +74,12 @@ class Waitable { class MessagePumpForUIStub : public base::MessagePumpForUI { virtual ~MessagePumpForUIStub() {} - virtual void Start(base::MessagePump::Delegate* delegate) OVERRIDE { + virtual void Start(base::MessagePump::Delegate* delegate) override { NOTREACHED() << "The Start() method shouldn't be called in test, using" " Run() method should be used."; } - virtual void Run(base::MessagePump::Delegate* delegate) OVERRIDE { + virtual void Run(base::MessagePump::Delegate* delegate) override { // The following was based on message_pump_glib.cc, except we're using a // WaitableEvent since there are no native message loop to use. RunState state(delegate, g_state ? g_state->run_depth + 1 : 1); @@ -119,16 +119,16 @@ class MessagePumpForUIStub : public base::MessagePumpForUI { g_state = previous_state; } - virtual void Quit() OVERRIDE { + virtual void Quit() override { Waitable::GetInstance()->Quit(); } - virtual void ScheduleWork() OVERRIDE { + virtual void ScheduleWork() override { Waitable::GetInstance()->Signal(); } virtual void ScheduleDelayedWork( - const base::TimeTicks& delayed_work_time) OVERRIDE { + const base::TimeTicks& delayed_work_time) override { Waitable::GetInstance()->Signal(); } }; diff --git a/base/threading/non_thread_safe_unittest.cc b/base/threading/non_thread_safe_unittest.cc index 8a82a63..2bd7629 100644 --- a/base/threading/non_thread_safe_unittest.cc +++ b/base/threading/non_thread_safe_unittest.cc @@ -52,7 +52,7 @@ class CallDoStuffOnThread : public SimpleThread { non_thread_safe_class_(non_thread_safe_class) { } - virtual void Run() OVERRIDE { + virtual void Run() override { non_thread_safe_class_->DoStuff(); } @@ -71,7 +71,7 @@ class DeleteNonThreadSafeClassOnThread : public SimpleThread { non_thread_safe_class_(non_thread_safe_class) { } - virtual void Run() OVERRIDE { + virtual void Run() override { non_thread_safe_class_.reset(); } diff --git a/base/threading/platform_thread_unittest.cc b/base/threading/platform_thread_unittest.cc index 59f29da..6859692 100644 --- a/base/threading/platform_thread_unittest.cc +++ b/base/threading/platform_thread_unittest.cc @@ -15,7 +15,7 @@ class TrivialThread : public PlatformThread::Delegate { public: TrivialThread() : did_run_(false) {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { did_run_ = true; } @@ -57,7 +57,7 @@ class FunctionTestThread : public TrivialThread { public: FunctionTestThread() : thread_id_(0) {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { thread_id_ = PlatformThread::CurrentId(); PlatformThread::YieldCurrentThread(); PlatformThread::Sleep(TimeDelta::FromMilliseconds(50)); diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc index 38b2998..5304f37 100644 --- a/base/threading/sequenced_worker_pool.cc +++ b/base/threading/sequenced_worker_pool.cc @@ -100,8 +100,8 @@ class SequencedWorkerPoolTaskRunner : public TaskRunner { // TaskRunner implementation virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; private: virtual ~SequencedWorkerPoolTaskRunner(); @@ -153,14 +153,14 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner { // TaskRunner implementation virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; // SequencedTaskRunner implementation virtual bool PostNonNestableDelayedTask( const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; + TimeDelta delay) override; private: virtual ~SequencedWorkerPoolSequencedTaskRunner(); @@ -238,7 +238,7 @@ class SequencedWorkerPool::Worker : public SimpleThread { virtual ~Worker(); // SimpleThread implementation. This actually runs the background thread. - virtual void Run() OVERRIDE; + virtual void Run() override; void set_running_task_info(SequenceToken token, WorkerShutdown shutdown_behavior) { diff --git a/base/threading/sequenced_worker_pool.h b/base/threading/sequenced_worker_pool.h index d3c85e2..4b1c749 100644 --- a/base/threading/sequenced_worker_pool.h +++ b/base/threading/sequenced_worker_pool.h @@ -292,8 +292,8 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner { // TaskRunner implementation. Forwards to PostDelayedWorkerTask(). virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; // Returns true if the current thread is processing a task with the given // sequence_token. @@ -338,7 +338,7 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner { protected: virtual ~SequencedWorkerPool(); - virtual void OnDestruct() const OVERRIDE; + virtual void OnDestruct() const override; private: friend class RefCountedThreadSafe<SequencedWorkerPool>; diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc index 10cf28b..b1fe276 100644 --- a/base/threading/sequenced_worker_pool_unittest.cc +++ b/base/threading/sequenced_worker_pool_unittest.cc @@ -185,9 +185,9 @@ class SequencedWorkerPoolTest : public testing::Test { virtual ~SequencedWorkerPoolTest() {} - virtual void SetUp() OVERRIDE {} + virtual void SetUp() override {} - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { pool()->Shutdown(); } diff --git a/base/threading/simple_thread.h b/base/threading/simple_thread.h index df03ce1..e734c29 100644 --- a/base/threading/simple_thread.h +++ b/base/threading/simple_thread.h @@ -102,7 +102,7 @@ class BASE_EXPORT SimpleThread : public PlatformThread::Delegate { bool HasBeenJoined() { return joined_; } // Overridden from PlatformThread::Delegate: - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; // Only set priorities with a careful understanding of the consequences. // This is meant for very limited use cases. @@ -136,7 +136,7 @@ class BASE_EXPORT DelegateSimpleThread : public SimpleThread { const Options& options); virtual ~DelegateSimpleThread(); - virtual void Run() OVERRIDE; + virtual void Run() override; private: Delegate* delegate_; }; @@ -174,7 +174,7 @@ class BASE_EXPORT DelegateSimpleThreadPool } // We implement the Delegate interface, for running our internal threads. - virtual void Run() OVERRIDE; + virtual void Run() override; private: const std::string name_prefix_; diff --git a/base/threading/simple_thread_unittest.cc b/base/threading/simple_thread_unittest.cc index a744b8d..89ddeba 100644 --- a/base/threading/simple_thread_unittest.cc +++ b/base/threading/simple_thread_unittest.cc @@ -17,7 +17,7 @@ class SetIntRunner : public DelegateSimpleThread::Delegate { SetIntRunner(int* ptr, int val) : ptr_(ptr), val_(val) { } virtual ~SetIntRunner() { } - virtual void Run() OVERRIDE { + virtual void Run() override { *ptr_ = val_; } @@ -31,7 +31,7 @@ class WaitEventRunner : public DelegateSimpleThread::Delegate { explicit WaitEventRunner(WaitableEvent* event) : event_(event) { } virtual ~WaitEventRunner() { } - virtual void Run() OVERRIDE { + virtual void Run() override { EXPECT_FALSE(event_->IsSignaled()); event_->Signal(); EXPECT_TRUE(event_->IsSignaled()); @@ -43,7 +43,7 @@ class WaitEventRunner : public DelegateSimpleThread::Delegate { class SeqRunner : public DelegateSimpleThread::Delegate { public: explicit SeqRunner(AtomicSequenceNumber* seq) : seq_(seq) { } - virtual void Run() OVERRIDE { + virtual void Run() override { seq_->GetNext(); } @@ -60,7 +60,7 @@ class VerifyPoolRunner : public DelegateSimpleThread::Delegate { int total, WaitableEvent* event) : seq_(seq), total_(total), event_(event) { } - virtual void Run() OVERRIDE { + virtual void Run() override { if (seq_->GetNext() == total_) { event_->Signal(); } else { diff --git a/base/threading/thread.h b/base/threading/thread.h index a0a3005..464a965 100644 --- a/base/threading/thread.h +++ b/base/threading/thread.h @@ -201,7 +201,7 @@ class BASE_EXPORT Thread : PlatformThread::Delegate { #endif // PlatformThread::Delegate methods: - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; #if defined(OS_WIN) // Whether this thread needs to initialize COM, and if so, in what mode. diff --git a/base/threading/thread_checker_unittest.cc b/base/threading/thread_checker_unittest.cc index ae96923..1084dd9 100644 --- a/base/threading/thread_checker_unittest.cc +++ b/base/threading/thread_checker_unittest.cc @@ -52,7 +52,7 @@ class CallDoStuffOnThread : public base::SimpleThread { thread_checker_class_(thread_checker_class) { } - virtual void Run() OVERRIDE { + virtual void Run() override { thread_checker_class_->DoStuff(); } @@ -71,7 +71,7 @@ class DeleteThreadCheckerClassOnThread : public base::SimpleThread { thread_checker_class_(thread_checker_class) { } - virtual void Run() OVERRIDE { + virtual void Run() override { thread_checker_class_.reset(); } diff --git a/base/threading/thread_collision_warner.h b/base/threading/thread_collision_warner.h index 5172b2e..0523c91 100644 --- a/base/threading/thread_collision_warner.h +++ b/base/threading/thread_collision_warner.h @@ -139,7 +139,7 @@ struct BASE_EXPORT AsserterBase { struct BASE_EXPORT DCheckAsserter : public AsserterBase { virtual ~DCheckAsserter() {} - virtual void warn() OVERRIDE; + virtual void warn() override; }; class BASE_EXPORT ThreadCollisionWarner { diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc index 48710a7..c7c7d0a 100644 --- a/base/threading/thread_collision_warner_unittest.cc +++ b/base/threading/thread_collision_warner_unittest.cc @@ -41,7 +41,7 @@ class AssertReporter : public base::AsserterBase { AssertReporter() : failed_(false) {} - virtual void warn() OVERRIDE { + virtual void warn() override { failed_ = true; } @@ -151,7 +151,7 @@ TEST(ThreadCollisionTest, MTBookCriticalSectionTest) { explicit QueueUser(NonThreadSafeQueue& queue) : queue_(queue) {} - virtual void Run() OVERRIDE { + virtual void Run() override { queue_.push(0); queue_.pop(); } @@ -209,7 +209,7 @@ TEST(ThreadCollisionTest, MTScopedBookCriticalSectionTest) { explicit QueueUser(NonThreadSafeQueue& queue) : queue_(queue) {} - virtual void Run() OVERRIDE { + virtual void Run() override { queue_.push(0); queue_.pop(); } @@ -270,7 +270,7 @@ TEST(ThreadCollisionTest, MTSynchedScopedBookCriticalSectionTest) { : queue_(queue), lock_(lock) {} - virtual void Run() OVERRIDE { + virtual void Run() override { { base::AutoLock auto_lock(lock_); queue_.push(0); @@ -344,7 +344,7 @@ TEST(ThreadCollisionTest, MTSynchedScopedRecursiveBookCriticalSectionTest) { : queue_(queue), lock_(lock) {} - virtual void Run() OVERRIDE { + virtual void Run() override { { base::AutoLock auto_lock(lock_); queue_.push(0); diff --git a/base/threading/thread_local_storage_unittest.cc b/base/threading/thread_local_storage_unittest.cc index 1bf71d1..321a058 100644 --- a/base/threading/thread_local_storage_unittest.cc +++ b/base/threading/thread_local_storage_unittest.cc @@ -35,7 +35,7 @@ class ThreadLocalStorageRunner : public DelegateSimpleThread::Delegate { virtual ~ThreadLocalStorageRunner() {} - virtual void Run() OVERRIDE { + virtual void Run() override { *tls_value_ptr_ = kInitialTlsValue; tls_slot.Set(tls_value_ptr_); diff --git a/base/threading/thread_local_unittest.cc b/base/threading/thread_local_unittest.cc index b125a48..9d0a7c9e 100644 --- a/base/threading/thread_local_unittest.cc +++ b/base/threading/thread_local_unittest.cc @@ -37,7 +37,7 @@ class SetThreadLocal : public ThreadLocalTesterBase { void set_value(ThreadLocalTesterBase* val) { val_ = val; } - virtual void Run() OVERRIDE { + virtual void Run() override { DCHECK(!done_->IsSignaled()); tlp_->Set(val_); done_->Signal(); @@ -57,7 +57,7 @@ class GetThreadLocal : public ThreadLocalTesterBase { void set_ptr(ThreadLocalTesterBase** ptr) { ptr_ = ptr; } - virtual void Run() OVERRIDE { + virtual void Run() override { DCHECK(!done_->IsSignaled()); *ptr_ = tlp_->Get(); done_->Signal(); diff --git a/base/threading/thread_perftest.cc b/base/threading/thread_perftest.cc index 088f629..2c9fabb 100644 --- a/base/threading/thread_perftest.cc +++ b/base/threading/thread_perftest.cc @@ -123,7 +123,7 @@ class TaskPerfTest : public ThreadPerfTest { return threads_[count % threads_.size()]; } - virtual void PingPong(int hops) OVERRIDE { + virtual void PingPong(int hops) override { if (!hops) { FinishMeasurement(); return; @@ -149,16 +149,16 @@ TEST_F(TaskPerfTest, TaskPingPong) { // Same as above, but add observers to test their perf impact. class MessageLoopObserver : public base::MessageLoop::TaskObserver { public: - virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE { + virtual void WillProcessTask(const base::PendingTask& pending_task) override { } - virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE { + virtual void DidProcessTask(const base::PendingTask& pending_task) override { } }; MessageLoopObserver message_loop_observer; class TaskObserverPerfTest : public TaskPerfTest { public: - virtual void Init() OVERRIDE { + virtual void Init() override { TaskPerfTest::Init(); for (size_t i = 0; i < threads_.size(); i++) { threads_[i]->message_loop()->AddTaskObserver(&message_loop_observer); @@ -176,12 +176,12 @@ TEST_F(TaskObserverPerfTest, TaskPingPong) { template <typename WaitableEventType> class EventPerfTest : public ThreadPerfTest { public: - virtual void Init() OVERRIDE { + virtual void Init() override { for (size_t i = 0; i < threads_.size(); i++) events_.push_back(new WaitableEventType(false, false)); } - virtual void Reset() OVERRIDE { events_.clear(); } + virtual void Reset() override { events_.clear(); } void WaitAndSignalOnThread(size_t event) { size_t next_event = (event + 1) % events_.size(); @@ -197,7 +197,7 @@ class EventPerfTest : public ThreadPerfTest { FinishMeasurement(); } - virtual void PingPong(int hops) OVERRIDE { + virtual void PingPong(int hops) override { remaining_hops_ = hops; for (size_t i = 0; i < threads_.size(); i++) { threads_[i]->message_loop_proxy()->PostTask( diff --git a/base/threading/thread_unittest.cc b/base/threading/thread_unittest.cc index 8bd817c..2bac84a 100644 --- a/base/threading/thread_unittest.cc +++ b/base/threading/thread_unittest.cc @@ -35,7 +35,7 @@ class SleepInsideInitThread : public Thread { Stop(); } - virtual void Init() OVERRIDE { + virtual void Init() override { base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500)); init_called_ = true; } @@ -74,11 +74,11 @@ class CaptureToEventList : public Thread { Stop(); } - virtual void Init() OVERRIDE { + virtual void Init() override { event_list_->push_back(THREAD_EVENT_INIT); } - virtual void CleanUp() OVERRIDE { + virtual void CleanUp() override { event_list_->push_back(THREAD_EVENT_CLEANUP); } @@ -97,7 +97,7 @@ class CapturingDestructionObserver } // DestructionObserver implementation: - virtual void WillDestroyCurrentMessageLoop() OVERRIDE { + virtual void WillDestroyCurrentMessageLoop() override { event_list_->push_back(THREAD_EVENT_MESSAGE_LOOP_DESTROYED); event_list_ = NULL; } diff --git a/base/threading/watchdog.h b/base/threading/watchdog.h index abcb4f1..fe43e48 100644 --- a/base/threading/watchdog.h +++ b/base/threading/watchdog.h @@ -65,7 +65,7 @@ class BASE_EXPORT Watchdog { public: explicit ThreadDelegate(Watchdog* watchdog) : watchdog_(watchdog) { } - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; private: void SetThreadName() const; diff --git a/base/threading/watchdog_unittest.cc b/base/threading/watchdog_unittest.cc index 7a4be4c..2dbfdbd 100644 --- a/base/threading/watchdog_unittest.cc +++ b/base/threading/watchdog_unittest.cc @@ -28,7 +28,7 @@ class WatchdogCounter : public Watchdog { virtual ~WatchdogCounter() {} - virtual void Alarm() OVERRIDE { + virtual void Alarm() override { alarm_counter_++; Watchdog::Alarm(); } @@ -43,7 +43,7 @@ class WatchdogCounter : public Watchdog { class WatchdogTest : public testing::Test { public: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { Watchdog::ResetStaticData(); } }; diff --git a/base/threading/worker_pool.cc b/base/threading/worker_pool.cc index 9e5e64c..5b57cab 100644 --- a/base/threading/worker_pool.cc +++ b/base/threading/worker_pool.cc @@ -24,7 +24,7 @@ class PostTaskAndReplyWorkerPool : public internal::PostTaskAndReplyImpl { private: virtual bool PostTask(const tracked_objects::Location& from_here, - const Closure& task) OVERRIDE { + const Closure& task) override { return WorkerPool::PostTask(from_here, task, task_is_slow_); } @@ -43,8 +43,8 @@ class WorkerPoolTaskRunner : public TaskRunner { // TaskRunner implementation virtual bool PostDelayedTask(const tracked_objects::Location& from_here, const Closure& task, - TimeDelta delay) OVERRIDE; - virtual bool RunsTasksOnCurrentThread() const OVERRIDE; + TimeDelta delay) override; + virtual bool RunsTasksOnCurrentThread() const override; private: virtual ~WorkerPoolTaskRunner(); diff --git a/base/threading/worker_pool_posix.cc b/base/threading/worker_pool_posix.cc index 167d20f..fbf4635 100644 --- a/base/threading/worker_pool_posix.cc +++ b/base/threading/worker_pool_posix.cc @@ -71,7 +71,7 @@ class WorkerThread : public PlatformThread::Delegate { : name_prefix_(name_prefix), pool_(pool) {} - virtual void ThreadMain() OVERRIDE; + virtual void ThreadMain() override; private: const std::string name_prefix_; diff --git a/base/threading/worker_pool_posix_unittest.cc b/base/threading/worker_pool_posix_unittest.cc index 862ffdd..b694155 100644 --- a/base/threading/worker_pool_posix_unittest.cc +++ b/base/threading/worker_pool_posix_unittest.cc @@ -97,11 +97,11 @@ class PosixDynamicThreadPoolTest : public testing::Test { num_waiting_to_start_cv_(&num_waiting_to_start_lock_), start_(true, false) {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { peer_.set_num_idle_threads_cv(new ConditionVariable(peer_.lock())); } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { // Wake up the idle threads so they can terminate. if (pool_.get()) pool_->Terminate(); } diff --git a/base/time/default_clock.h b/base/time/default_clock.h index 2022d5c..98bca1a 100644 --- a/base/time/default_clock.h +++ b/base/time/default_clock.h @@ -17,7 +17,7 @@ class BASE_EXPORT DefaultClock : public Clock { virtual ~DefaultClock(); // Simply returns Time::Now(). - virtual Time Now() OVERRIDE; + virtual Time Now() override; }; } // namespace base diff --git a/base/time/default_tick_clock.h b/base/time/default_tick_clock.h index 553a8d2..b3d5a31 100644 --- a/base/time/default_tick_clock.h +++ b/base/time/default_tick_clock.h @@ -17,7 +17,7 @@ class BASE_EXPORT DefaultTickClock : public TickClock { virtual ~DefaultTickClock(); // Simply returns TimeTicks::Now(). - virtual TimeTicks NowTicks() OVERRIDE; + virtual TimeTicks NowTicks() override; }; } // namespace base diff --git a/base/time/pr_time_unittest.cc b/base/time/pr_time_unittest.cc index 105b8e4..2853e964 100644 --- a/base/time/pr_time_unittest.cc +++ b/base/time/pr_time_unittest.cc @@ -25,7 +25,7 @@ PRTime comparison_time_2 = INT64_C(1373275692441381); // represented as GMT // tested by comparing them to a known time in the local zone. class PRTimeTest : public testing::Test { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { // Use mktime to get a time_t, and turn it into a PRTime by converting // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This // must be a time guaranteed to be outside of a DST fallback hour in diff --git a/base/time/time_unittest.cc b/base/time/time_unittest.cc index 63c3a1a..d8f1e5e 100644 --- a/base/time/time_unittest.cc +++ b/base/time/time_unittest.cc @@ -22,7 +22,7 @@ using base::TimeTicks; // See also pr_time_unittests.cc class TimeTest : public testing::Test { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { // Use mktime to get a time_t, and turn it into a PRTime by converting // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This // must be a time guaranteed to be outside of a DST fallback hour in diff --git a/base/timer/hi_res_timer_manager.h b/base/timer/hi_res_timer_manager.h index 7fcdb0d..bfe1f4d 100644 --- a/base/timer/hi_res_timer_manager.h +++ b/base/timer/hi_res_timer_manager.h @@ -19,7 +19,7 @@ class BASE_EXPORT HighResolutionTimerManager : public base::PowerObserver { virtual ~HighResolutionTimerManager(); // base::PowerObserver method. - virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE; + virtual void OnPowerStateChange(bool on_battery_power) override; // Returns true if the hi resolution clock could be used right now. bool hi_res_clock_available() const { return hi_res_clock_available_; } diff --git a/base/timer/mock_timer.h b/base/timer/mock_timer.h index 456cb5b..c4aa92e 100644 --- a/base/timer/mock_timer.h +++ b/base/timer/mock_timer.h @@ -19,13 +19,13 @@ class BASE_EXPORT MockTimer : public Timer { virtual ~MockTimer(); // base::Timer implementation. - virtual bool IsRunning() const OVERRIDE; - virtual base::TimeDelta GetCurrentDelay() const OVERRIDE; + virtual bool IsRunning() const override; + virtual base::TimeDelta GetCurrentDelay() const override; virtual void Start(const tracked_objects::Location& posted_from, base::TimeDelta delay, - const base::Closure& user_task) OVERRIDE; - virtual void Stop() OVERRIDE; - virtual void Reset() OVERRIDE; + const base::Closure& user_task) override; + virtual void Stop() override; + virtual void Reset() override; // Testing methods. void Fire(); diff --git a/base/tools_sanity_unittest.cc b/base/tools_sanity_unittest.cc index 00eecb4..d61d1c2 100644 --- a/base/tools_sanity_unittest.cc +++ b/base/tools_sanity_unittest.cc @@ -239,7 +239,7 @@ class TOOLS_SANITY_TEST_CONCURRENT_THREAD : public PlatformThread::Delegate { public: explicit TOOLS_SANITY_TEST_CONCURRENT_THREAD(bool *value) : value_(value) {} virtual ~TOOLS_SANITY_TEST_CONCURRENT_THREAD() {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { *value_ = true; // Sleep for a few milliseconds so the two threads are more likely to live @@ -255,7 +255,7 @@ class ReleaseStoreThread : public PlatformThread::Delegate { public: explicit ReleaseStoreThread(base::subtle::Atomic32 *value) : value_(value) {} virtual ~ReleaseStoreThread() {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { base::subtle::Release_Store(value_, kMagicValue); // Sleep for a few milliseconds so the two threads are more likely to live @@ -271,7 +271,7 @@ class AcquireLoadThread : public PlatformThread::Delegate { public: explicit AcquireLoadThread(base::subtle::Atomic32 *value) : value_(value) {} virtual ~AcquireLoadThread() {} - virtual void ThreadMain() OVERRIDE { + virtual void ThreadMain() override { // Wait for the other thread to make Release_Store PlatformThread::Sleep(TimeDelta::FromMilliseconds(100)); base::subtle::Acquire_Load(value_); diff --git a/base/values.h b/base/values.h index d5e6313..68dd9c8 100644 --- a/base/values.h +++ b/base/values.h @@ -124,13 +124,13 @@ class BASE_EXPORT FundamentalValue : public Value { virtual ~FundamentalValue(); // Overridden from Value: - virtual bool GetAsBoolean(bool* out_value) const OVERRIDE; - virtual bool GetAsInteger(int* out_value) const OVERRIDE; + virtual bool GetAsBoolean(bool* out_value) const override; + virtual bool GetAsInteger(int* out_value) const override; // Values of both type TYPE_INTEGER and TYPE_DOUBLE can be obtained as // doubles. - virtual bool GetAsDouble(double* out_value) const OVERRIDE; - virtual FundamentalValue* DeepCopy() const OVERRIDE; - virtual bool Equals(const Value* other) const OVERRIDE; + virtual bool GetAsDouble(double* out_value) const override; + virtual FundamentalValue* DeepCopy() const override; + virtual bool Equals(const Value* other) const override; private: union { @@ -155,11 +155,11 @@ class BASE_EXPORT StringValue : public Value { const std::string& GetString() const; // Overridden from Value: - virtual bool GetAsString(std::string* out_value) const OVERRIDE; - virtual bool GetAsString(string16* out_value) const OVERRIDE; - virtual bool GetAsString(const StringValue** out_value) const OVERRIDE; - virtual StringValue* DeepCopy() const OVERRIDE; - virtual bool Equals(const Value* other) const OVERRIDE; + virtual bool GetAsString(std::string* out_value) const override; + virtual bool GetAsString(string16* out_value) const override; + virtual bool GetAsString(const StringValue** out_value) const override; + virtual StringValue* DeepCopy() const override; + virtual bool Equals(const Value* other) const override; private: std::string value_; @@ -188,8 +188,8 @@ class BASE_EXPORT BinaryValue: public Value { const char* GetBuffer() const { return buffer_.get(); } // Overridden from Value: - virtual BinaryValue* DeepCopy() const OVERRIDE; - virtual bool Equals(const Value* other) const OVERRIDE; + virtual BinaryValue* DeepCopy() const override; + virtual bool Equals(const Value* other) const override; private: scoped_ptr<char[]> buffer_; @@ -207,9 +207,9 @@ class BASE_EXPORT DictionaryValue : public Value { virtual ~DictionaryValue(); // Overridden from Value: - virtual bool GetAsDictionary(DictionaryValue** out_value) OVERRIDE; + virtual bool GetAsDictionary(DictionaryValue** out_value) override; virtual bool GetAsDictionary( - const DictionaryValue** out_value) const OVERRIDE; + const DictionaryValue** out_value) const override; // Returns true if the current dictionary has a value for the given key. bool HasKey(const std::string& key) const; @@ -362,8 +362,8 @@ class BASE_EXPORT DictionaryValue : public Value { }; // Overridden from Value: - virtual DictionaryValue* DeepCopy() const OVERRIDE; - virtual bool Equals(const Value* other) const OVERRIDE; + virtual DictionaryValue* DeepCopy() const override; + virtual bool Equals(const Value* other) const override; private: ValueMap dictionary_; @@ -476,10 +476,10 @@ class BASE_EXPORT ListValue : public Value { const_iterator end() const { return list_.end(); } // Overridden from Value: - virtual bool GetAsList(ListValue** out_value) OVERRIDE; - virtual bool GetAsList(const ListValue** out_value) const OVERRIDE; - virtual ListValue* DeepCopy() const OVERRIDE; - virtual bool Equals(const Value* other) const OVERRIDE; + virtual bool GetAsList(ListValue** out_value) override; + virtual bool GetAsList(const ListValue** out_value) const override; + virtual ListValue* DeepCopy() const override; + virtual bool Equals(const Value* other) const override; private: ValueVector list_; diff --git a/base/win/enum_variant.h b/base/win/enum_variant.h index 82f8750..030f7fd 100644 --- a/base/win/enum_variant.h +++ b/base/win/enum_variant.h @@ -26,9 +26,9 @@ class BASE_EXPORT EnumVariant VARIANT* ItemAt(unsigned long index); // IUnknown. - ULONG STDMETHODCALLTYPE AddRef() OVERRIDE; - ULONG STDMETHODCALLTYPE Release() OVERRIDE; - STDMETHODIMP QueryInterface(REFIID riid, void** ppv) OVERRIDE; + ULONG STDMETHODCALLTYPE AddRef() override; + ULONG STDMETHODCALLTYPE Release() override; + STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override; // IEnumVARIANT. STDMETHODIMP Next(ULONG requested_count, diff --git a/base/win/iunknown_impl.h b/base/win/iunknown_impl.h index ff7e870..4283d02 100644 --- a/base/win/iunknown_impl.h +++ b/base/win/iunknown_impl.h @@ -19,11 +19,11 @@ class BASE_EXPORT IUnknownImpl : public IUnknown { public: IUnknownImpl(); - virtual ULONG STDMETHODCALLTYPE AddRef() OVERRIDE; - virtual ULONG STDMETHODCALLTYPE Release() OVERRIDE; + virtual ULONG STDMETHODCALLTYPE AddRef() override; + virtual ULONG STDMETHODCALLTYPE Release() override; // Subclasses should extend this to return any interfaces they provide. - virtual STDMETHODIMP QueryInterface(REFIID riid, void** ppv) OVERRIDE; + virtual STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override; protected: virtual ~IUnknownImpl(); diff --git a/base/win/registry_unittest.cc b/base/win/registry_unittest.cc index 84074b3..d2610ef 100644 --- a/base/win/registry_unittest.cc +++ b/base/win/registry_unittest.cc @@ -28,7 +28,7 @@ class RegistryTest : public testing::Test { #endif // _WIN64 RegistryTest() {} - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { // Create a temporary key. RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS); key.DeleteKey(kRootKey); @@ -39,7 +39,7 @@ class RegistryTest : public testing::Test { foo_software_key_ += L"\\Foo"; } - virtual void TearDown() OVERRIDE { + virtual void TearDown() override { // Clean up the temporary key. RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE); ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); diff --git a/base/win/shortcut_unittest.cc b/base/win/shortcut_unittest.cc index 53fbd34..4bb227a 100644 --- a/base/win/shortcut_unittest.cc +++ b/base/win/shortcut_unittest.cc @@ -25,7 +25,7 @@ static const char kFileContents2[] = "This is another target."; class ShortcutTest : public testing::Test { protected: - virtual void SetUp() OVERRIDE { + virtual void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); ASSERT_TRUE(temp_dir_2_.CreateUniqueTempDir()); |