Add OVERRIDE to jingle/.

jingle/notifier/base/chrome_async_socket.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // An implementation of buzz::AsyncSocket that uses Chrome sockets.
 
 #ifndef JINGLE_NOTIFIER_BASE_CHROME_ASYNC_SOCKET_H_
 #define JINGLE_NOTIFIER_BASE_CHROME_ASYNC_SOCKET_H_
 
 #if !defined(FEATURE_ENABLE_SSL)
 #error ChromeAsyncSocket expects FEATURE_ENABLE_SSL to be defined
 #endif
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "talk/xmpp/asyncsocket.h"
 
 namespace net {
 class IOBufferWithSize;
 class StreamSocket;
@@ skipping 10 matching lines @@
                     size_t read_buf_size,
                     size_t write_buf_size);
 
   // Does not raise any signals.
   virtual ~ChromeAsyncSocket();
 
   // buzz::AsyncSocket implementation.
 
   // The current state (see buzz::AsyncSocket::State; all but
   // STATE_CLOSING is used).
-  virtual State state();
+  virtual State state() OVERRIDE;
 
   // The last generated error.  Errors are generated when the main
   // functions below return false or when SignalClosed is raised due
   // to an asynchronous error.
-  virtual Error error();
+  virtual Error error() OVERRIDE;
 
   // GetError() (which is of type net::Error) != net::OK only when
   // error() == ERROR_WINSOCK.
-  virtual int GetError();
+  virtual int GetError() OVERRIDE;
 
   // Tries to connect to the given address.
   //
   // If state() is not STATE_CLOSED, sets error to ERROR_WRONGSTATE
   // and returns false.
   //
   // If |address| is not resolved, sets error to ERROR_DNS and returns
   // false.
   //
   // Otherwise, starts the connection process and returns true.
   // SignalConnected will be raised when the connection is successful;
   // otherwise, SignalClosed will be raised with a net error set.
-  virtual bool Connect(const talk_base::SocketAddress& address);
+  virtual bool Connect(const talk_base::SocketAddress& address) OVERRIDE;
 
   // Tries to read at most |len| bytes into |data|.
   //
   // If state() is not STATE_TLS_CONNECTING, STATE_OPEN, or
   // STATE_TLS_OPEN, sets error to ERROR_WRONGSTATE and returns false.
   //
   // Otherwise, fills in |len_read| with the number of bytes read and
   // returns true.  If this is called when state() is
   // STATE_TLS_CONNECTING, reads 0 bytes.  (We have to handle this
   // case because StartTls() is called during a slot connected to
   // SignalRead after parsing the final non-TLS reply from the server
   // [see XmppClient::Private::OnSocketRead()].)
-  virtual bool Read(char* data, size_t len, size_t* len_read);
+  virtual bool Read(char* data, size_t len, size_t* len_read) OVERRIDE;
 
   // Queues up |len| bytes of |data| for writing.
   //
   // If state() is not STATE_TLS_CONNECTING, STATE_OPEN, or
   // STATE_TLS_OPEN, sets error to ERROR_WRONGSTATE and returns false.
   //
   // If the given data is too big for the internal write buffer, sets
   // error to ERROR_WINSOCK/net::ERR_INSUFFICIENT_RESOURCES and
   // returns false.
   //
   // Otherwise, queues up the data and returns true.  If this is
   // called when state() == STATE_TLS_CONNECTING, the data is will be
   // sent only after the TLS connection succeeds.  (See StartTls()
   // below for why this happens.)
   //
   // Note that there's no guarantee that the data will actually be
   // sent; however, it is guaranteed that the any data sent will be
   // sent in FIFO order.
-  virtual bool Write(const char* data, size_t len);
+  virtual bool Write(const char* data, size_t len) OVERRIDE;
 
   // If the socket is not already closed, closes the socket and raises
   // SignalClosed.  Always returns true.
-  virtual bool Close();
+  virtual bool Close() OVERRIDE;
 
   // Tries to change to a TLS connection with the given domain name.
   //
   // If state() is not STATE_OPEN or there are pending reads or
   // writes, sets error to ERROR_WRONGSTATE and returns false.  (In
   // practice, this means that StartTls() can only be called from a
   // slot connected to SignalRead.)
   //
   // Otherwise, starts the TLS connection process and returns true.
   // SignalSSLConnected will be raised when the connection is
   // successful; otherwise, SignalClosed will be raised with a net
   // error set.
-  virtual bool StartTls(const std::string& domain_name);
+  virtual bool StartTls(const std::string& domain_name) OVERRIDE;
 
   // Signal behavior:
   //
   // SignalConnected: raised whenever the connect initiated by a call
   // to Connect() is complete.
   //
   // SignalSSLConnected: raised whenever the connect initiated by a
   // call to StartTls() is complete.  Not actually used by
   // XmppClient. (It just assumes that if SignalRead is raised after a
   // call to StartTls(), the connection has been successfully
@@ skipping 79 matching lines @@
   AsyncIOState write_state_;
   scoped_refptr<net::IOBufferWithSize> write_buf_;
   size_t write_end_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeAsyncSocket);
 };
 
 }  // namespace notifier
 
 #endif  // JINGLE_NOTIFIER_BASE_CHROME_ASYNC_SOCKET_H_