win: Fix a few clang style plugin warnings.

base/message_loop/message_pump_win.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 
 #include <windows.h>
 
 #include <list>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/message_loop/message_pump.h"
 #include "base/message_loop/message_pump_dispatcher.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
 
 // MessagePumpWin serves as the base for specialized versions of the MessagePump
 // for Windows. It provides basic functionality like handling of observers and
 // controlling the lifetime of the message pump.
 class BASE_EXPORT MessagePumpWin : public MessagePump {
  public:
   MessagePumpWin() : have_work_(0), state_(NULL) {}
-  virtual ~MessagePumpWin() {}

[dcheng, 2015/04/16 21:03:26]

How don't we don't need this? I guess the plugin only complains if we explicitly
have this line and doesn't actually care about the inline-ness?

[Nico, 2015/04/16 21:06:58]

It complains "virtual methods shouldn't be inline", but it doesn't say "complex
class has inline dtor" for this class – i guess this class has mostly pod
members, so it's below the threshold and the inline dtor is deemed small enough?

(but i didn't try this on win – maybe i'll have to send a follow-up and put this
back :-P)

 
   // Like MessagePump::Run, but MSG objects are routed through dispatcher.
   void RunWithDispatcher(Delegate* delegate, MessagePumpDispatcher* dispatcher);
 
   // MessagePump methods:
-  virtual void Run(Delegate* delegate) { RunWithDispatcher(delegate, NULL); }
-  virtual void Quit();
+  void Run(Delegate* delegate) override;
+  void Quit() override;
 
  protected:
   struct RunState {
     Delegate* delegate;
     MessagePumpDispatcher* dispatcher;
 
     // Used to flag that the current Run() invocation should return ASAP.
     bool should_quit;
 
     // Used to count how many Run() invocations are on the stack.
@@ skipping 65 matching lines @@
 //
 class BASE_EXPORT MessagePumpForUI : public MessagePumpWin {
  public:
   // The application-defined code passed to the hook procedure.
   static const int kMessageFilterCode = 0x5001;
 
   MessagePumpForUI();
   virtual ~MessagePumpForUI();
 
   // MessagePump methods:
-  virtual void ScheduleWork();
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);
+  void ScheduleWork() override;
+  void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   static LRESULT CALLBACK WndProcThunk(HWND window_handle,
                                        UINT message,
                                        WPARAM wparam,
                                        LPARAM lparam);
-  virtual void DoRunLoop();
+  void DoRunLoop() override;
   void InitMessageWnd();
   void WaitForWork();
   void HandleWorkMessage();
   void HandleTimerMessage();
   bool ProcessNextWindowsMessage();
   bool ProcessMessageHelper(const MSG& msg);
   bool ProcessPumpReplacementMessage();
 
   // Atom representing the registered window class.
   ATOM atom_;
@@ skipping 120 matching lines @@
   // notifies the completion of this operation. Please remember that any buffers
   // involved with an IO operation should be around until the callback is
   // received, so this technique can only be used for IO that do not involve
   // additional buffers (other than the overlapped structure itself).
   struct IOContext {
     OVERLAPPED overlapped;
     IOHandler* handler;
   };
 
   MessagePumpForIO();
-  virtual ~MessagePumpForIO() {}
+  ~MessagePumpForIO() override;
 
   // MessagePump methods:
-  virtual void ScheduleWork();
-  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);
+  void ScheduleWork() override;
+  void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
   // Register the handler to be used when asynchronous IO for the given file
   // completes. The registration persists as long as |file_handle| is valid, so
   // |handler| must be valid as long as there is pending IO for the given file.
   void RegisterIOHandler(HANDLE file_handle, IOHandler* handler);
 
   // Register the handler to be used to process job events. The registration
   // persists as long as the job object is live, so |handler| must be valid
   // until the job object is destroyed. Returns true if the registration
   // succeeded, and false otherwise.
@@ skipping 19 matching lines @@
     IOContext* context;
     DWORD bytes_transfered;
     DWORD error;
 
     // In some cases |context| can be a non-pointer value casted to a pointer.
     // |has_valid_io_context| is true if |context| is a valid IOContext
     // pointer, and false otherwise.
     bool has_valid_io_context;
   };
 
-  virtual void DoRunLoop();
+  void DoRunLoop() override;
   void WaitForWork();
   bool MatchCompletedIOItem(IOHandler* filter, IOItem* item);
   bool GetIOItem(DWORD timeout, IOItem* item);
   bool ProcessInternalIOItem(const IOItem& item);
   void WillProcessIOEvent();
   void DidProcessIOEvent();
 
   // Converts an IOHandler pointer to a completion port key.
   // |has_valid_io_context| specifies whether completion packets posted to
   // |handler| will have valid OVERLAPPED pointers.
   static ULONG_PTR HandlerToKey(IOHandler* handler, bool has_valid_io_context);
 
   // Converts a completion port key to an IOHandler pointer.
   static IOHandler* KeyToHandler(ULONG_PTR key, bool* has_valid_io_context);
 
   // The completion port associated with this thread.
   win::ScopedHandle port_;
   // This list will be empty almost always. It stores IO completions that have
   // not been delivered yet because somebody was doing cleanup.
   std::list<IOItem> completed_io_;
 
   ObserverList<IOObserver> io_observers_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_