Clang format slam.

net/base/net_log.cc

 // 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.
 
 #include "net/base/net_log.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 87 matching lines @@
   return base::Bind(&SourceEventParametersCallback, *this);
 }
 
 // static
 bool NetLog::Source::FromEventParameters(base::Value* event_params,
                                          Source* source) {
   base::DictionaryValue* dict;
   base::DictionaryValue* source_dict;
   int source_id;
   int source_type;
-  if (!event_params ||
-      !event_params->GetAsDictionary(&dict) ||
+  if (!event_params || !event_params->GetAsDictionary(&dict) ||
       !dict->GetDictionary("source_dependency", &source_dict) ||
       !source_dict->GetInteger("id", &source_id) ||
       !source_dict->GetInteger("type", &source_type)) {
     *source = Source();
     return false;
   }
 
   DCHECK_LE(0, source_id);
   DCHECK_LT(source_type, NetLog::SOURCE_COUNT);
   *source = Source(static_cast<SourceType>(source_type), source_id);
@@ skipping 24 matching lines @@
 
   return entry_dict;
 }
 
 base::Value* NetLog::Entry::ParametersToValue() const {
   if (data_->parameters_callback)
     return data_->parameters_callback->Run(log_level_);
   return NULL;
 }
 
-NetLog::EntryData::EntryData(
-    EventType type,
-    Source source,
-    EventPhase phase,
-    base::TimeTicks time,
-    const ParametersCallback* parameters_callback)
+NetLog::EntryData::EntryData(EventType type,
+                             Source source,
+                             EventPhase phase,
+                             base::TimeTicks time,
+                             const ParametersCallback* parameters_callback)
     : type(type),
       source(source),
       phase(phase),
       time(time),
       parameters_callback(parameters_callback) {
 }
 
 NetLog::EntryData::~EntryData() {
 }
 
 NetLog::Entry::Entry(const EntryData* data, LogLevel log_level)
     : data_(data), log_level_(log_level) {
 }
 
 NetLog::Entry::~Entry() {
 }
 
-NetLog::ThreadSafeObserver::ThreadSafeObserver() : log_level_(LOG_NONE),
-                                                   net_log_(NULL) {
+NetLog::ThreadSafeObserver::ThreadSafeObserver()
+    : log_level_(LOG_NONE), net_log_(NULL) {
 }
 
 NetLog::ThreadSafeObserver::~ThreadSafeObserver() {
   // Make sure we aren't watching a NetLog on destruction.  Because the NetLog
   // may pass events to each observer on multiple threads, we cannot safely
   // stop watching a NetLog automatically from a parent class.
   DCHECK(!net_log_);
 }
 
 NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
   DCHECK(net_log_);
   return log_level_;
 }
 
 NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
 void NetLog::ThreadSafeObserver::OnAddEntryData(const EntryData& entry_data) {
   OnAddEntry(Entry(&entry_data, log_level()));
 }
 
 NetLog::NetLog()
-    : last_id_(0),
-      base_log_level_(LOG_NONE),
-      effective_log_level_(LOG_NONE) {
+    : last_id_(0), base_log_level_(LOG_NONE), effective_log_level_(LOG_NONE) {
 }
 
 NetLog::~NetLog() {
 }
 
 void NetLog::AddGlobalEntry(EventType type) {
   AddEntry(type,
            Source(net::NetLog::SOURCE_NONE, NextID()),
            net::NetLog::PHASE_NONE,
            NULL);
@@ skipping 18 matching lines @@
 
   UpdateLogLevel();
 }
 
 NetLog::LogLevel NetLog::GetLogLevel() const {
   base::subtle::Atomic32 log_level =
       base::subtle::NoBarrier_Load(&effective_log_level_);
   return static_cast<net::NetLog::LogLevel>(log_level);
 }
 
-void NetLog::AddThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer,
-    LogLevel log_level) {
+void NetLog::AddThreadSafeObserver(net::NetLog::ThreadSafeObserver* observer,
+                                   LogLevel log_level) {
   DCHECK_NE(LOG_NONE, log_level);
   base::AutoLock lock(lock_);
 
   DCHECK(!observer->net_log_);
   DCHECK_EQ(LOG_NONE, observer->log_level_);
   observers_.AddObserver(observer);
   observer->net_log_ = this;
   observer->log_level_ = log_level;
   UpdateLogLevel();
 }
 
-void NetLog::SetObserverLogLevel(
-    net::NetLog::ThreadSafeObserver* observer,
-    LogLevel log_level) {
+void NetLog::SetObserverLogLevel(net::NetLog::ThreadSafeObserver* observer,
+                                 LogLevel log_level) {
   DCHECK_NE(LOG_NONE, log_level);
   base::AutoLock lock(lock_);
 
   DCHECK(observers_.HasObserver(observer));
   DCHECK_EQ(this, observer->net_log_);
   DCHECK_NE(LOG_NONE, observer->log_level_);
   observer->log_level_ = log_level;
   UpdateLogLevel();
 }
 
@@ skipping 15 matching lines @@
 
   // Look through all the observers and find the finest granularity
   // log level (higher values of the enum imply *lower* log levels).
   LogLevel new_effective_log_level = base_log_level_;
   ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
   ThreadSafeObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     new_effective_log_level =
         std::min(new_effective_log_level, observer->log_level());
   }
-  base::subtle::NoBarrier_Store(&effective_log_level_,
-                                new_effective_log_level);
+  base::subtle::NoBarrier_Store(&effective_log_level_, new_effective_log_level);
 }
 
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
   return base::Int64ToString(delta_time);
 }
 
 // static
 const char* NetLog::EventTypeToString(EventType event) {
   switch (event) {
-#define EVENT_TYPE(label) case TYPE_ ## label: return #label;
+#define EVENT_TYPE(label) \
+  case TYPE_##label:      \
+    return #label;
 #include "net/base/net_log_event_type_list.h"
 #undef EVENT_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetEventTypesAsValue() {
   base::DictionaryValue* dict = new base::DictionaryValue();
   for (int i = 0; i < EVENT_COUNT; ++i) {
     dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i);
   }
   return dict;
 }
 
 // static
 const char* NetLog::SourceTypeToString(SourceType source) {
   switch (source) {
-#define SOURCE_TYPE(label) case SOURCE_ ## label: return #label;
+#define SOURCE_TYPE(label) \
+  case SOURCE_##label:     \
+    return #label;
 #include "net/base/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetSourceTypesAsValue() {
@@ skipping 53 matching lines @@
   DCHECK(value);
   return base::Bind(&NetLogString16Callback, name, value);
 }
 
 void NetLog::AddEntry(EventType type,
                       const Source& source,
                       EventPhase phase,
                       const NetLog::ParametersCallback* parameters_callback) {
   if (GetLogLevel() == LOG_NONE)
     return;
-  EntryData entry_data(type, source, phase, base::TimeTicks::Now(),
-                       parameters_callback);
+  EntryData entry_data(
+      type, source, phase, base::TimeTicks::Now(), parameters_callback);
 
   // Notify all of the log observers.
   base::AutoLock lock(lock_);
   FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntryData(entry_data));
 }
 
 void BoundNetLog::AddEntry(NetLog::EventType type,
                            NetLog::EventPhase phase) const {
   if (!net_log_)
     return;
@@ skipping 73 matching lines @@
 
 bool BoundNetLog::IsLoggingBytes() const {
   return NetLog::IsLoggingBytes(GetLogLevel());
 }
 
 bool BoundNetLog::IsLogging() const {
   return NetLog::IsLogging(GetLogLevel());
 }
 
 // static
-BoundNetLog BoundNetLog::Make(NetLog* net_log,
-                              NetLog::SourceType source_type) {
+BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLog::SourceType source_type) {
   if (!net_log)
     return BoundNetLog();
 
   NetLog::Source source(source_type, net_log->NextID());
   return BoundNetLog(source, net_log);
 }
 
 }  // namespace net