git cl format the final third of the net/base directory

net/base/net_log.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 NET_BASE_NET_LOG_H_
 #define NET_BASE_NET_LOG_H_
 
 #include <string>
 
 #include "base/atomicops.h"
@@ skipping 24 matching lines @@
 //
 // All methods are thread safe, with the exception that no NetLog or
 // NetLog::ThreadSafeObserver functions may be called by an observer's
 // OnAddEntry() method.  Doing so will result in a deadlock.
 //
 // For a broader introduction see the design document:
 // https://sites.google.com/a/chromium.org/dev/developers/design-documents/network-stack/netlog
 class NET_EXPORT NetLog {
  public:
   enum EventType {
-#define EVENT_TYPE(label) TYPE_ ## label,
+#define EVENT_TYPE(label) TYPE_##label,
 #include "net/base/net_log_event_type_list.h"
 #undef EVENT_TYPE
     EVENT_COUNT
   };
 
   // The 'phase' of an event trace (whether it marks the beginning or end
   // of an event.).
   enum EventPhase {
     PHASE_NONE,
     PHASE_BEGIN,
     PHASE_END,
   };
 
   // The "source" identifies the entity that generated the log message.
   enum SourceType {
-#define SOURCE_TYPE(label) SOURCE_ ## label,
+#define SOURCE_TYPE(label) SOURCE_##label,
 #include "net/base/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     SOURCE_COUNT
   };
 
   // Specifies the granularity of events that should be emitted to the log.
   //
   // Since the LogLevel may be read and set on any thread without locking, it
   // may be possible for an Observer to receive an event or parameters that
   // normally wouldn't be logged at the currently active log level.
@@ skipping 291 matching lines @@
   // Just like EndEvent, except |net_error| is a net error code.  If it's
   // negative, a parameter called "net_error" with a value of |net_error| is
   // associated with the event.  Otherwise, the end event has no parameters.
   // |net_error| must not be ERR_IO_PENDING, as it's not a true error.
   void EndEventWithNetErrorCode(NetLog::EventType event_type,
                                 int net_error) const;
 
   // Logs a byte transfer event to the NetLog.  Determines whether to log the
   // received bytes or not based on the current logging level.
   void AddByteTransferEvent(NetLog::EventType event_type,
-                            int byte_count, const char* bytes) const;
+                            int byte_count,
+                            const char* bytes) const;
 
   NetLog::LogLevel GetLogLevel() const;
 
   // Shortcut for NetLog::IsLoggingBytes(this->GetLogLevel()).
   bool IsLoggingBytes() const;
 
   // Shortcut for NetLog::IsLogging(this->GetLogLevel()).
   bool IsLogging() const;
 
   // Helper to create a BoundNetLog given a NetLog and a SourceType. Takes care
   // of creating a unique source ID, and handles the case of NULL net_log.
   static BoundNetLog Make(NetLog* net_log, NetLog::SourceType source_type);
 
   const NetLog::Source& source() const { return source_; }
   NetLog* net_log() const { return net_log_; }
 
  private:
   BoundNetLog(const NetLog::Source& source, NetLog* net_log)
-      : source_(source), net_log_(net_log) {
-  }
+      : source_(source), net_log_(net_log) {}

[mef, 2014/10/10 20:38:17]

Hmm, in many cases it seems to split {} into 2 lines, but here it actually
combined them into 1.

 
   NetLog::Source source_;
   NetLog* net_log_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_