Clang format slam.

net/base/directory_lister.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/directory_lister.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
   else if (sort_type == DirectoryLister::ALPHA_DIRS_FIRST)
     std::sort(data->begin(), data->end(), CompareAlphaDirsFirst);
   else
     DCHECK_EQ(DirectoryLister::NO_SORT, sort_type);
 }
 
 }  // namespace
 
 DirectoryLister::DirectoryLister(const base::FilePath& dir,
                                  DirectoryListerDelegate* delegate)
-    : core_(new Core(dir, false, ALPHA_DIRS_FIRST, this)),
-      delegate_(delegate) {
+    : core_(new Core(dir, false, ALPHA_DIRS_FIRST, this)), delegate_(delegate) {
   DCHECK(delegate_);
   DCHECK(!dir.value().empty());
 }
 
 DirectoryLister::DirectoryLister(const base::FilePath& dir,
                                  bool recursive,
                                  SortType sort,
                                  DirectoryListerDelegate* delegate)
-    : core_(new Core(dir, recursive, sort, this)),
-      delegate_(delegate) {
+    : core_(new Core(dir, recursive, sort, this)), delegate_(delegate) {
   DCHECK(delegate_);
   DCHECK(!dir.value().empty());
 }
 
 DirectoryLister::~DirectoryLister() {
   Cancel();
 }
 
 bool DirectoryLister::Start() {
   return core_->Start();
 }
 
 void DirectoryLister::Cancel() {
   return core_->Cancel();
 }
 
 DirectoryLister::Core::Core(const base::FilePath& dir,
                             bool recursive,
                             SortType sort,
                             DirectoryLister* lister)
-    : dir_(dir),
-      recursive_(recursive),
-      sort_(sort),
-      lister_(lister) {
+    : dir_(dir), recursive_(recursive), sort_(sort), lister_(lister) {
   DCHECK(lister_);
 }
 
-DirectoryLister::Core::~Core() {}
+DirectoryLister::Core::~Core() {
+}
 
 bool DirectoryLister::Core::Start() {
   origin_loop_ = base::MessageLoopProxy::current();
 
   return base::WorkerPool::PostTask(
       FROM_HERE, base::Bind(&Core::StartInternal, this), true);
 }
 
 void DirectoryLister::Core::Cancel() {
   lister_ = NULL;
 }
 
 void DirectoryLister::Core::StartInternal() {
-
   if (!base::DirectoryExists(dir_)) {
     origin_loop_->PostTask(
         FROM_HERE,
         base::Bind(&DirectoryLister::Core::OnDone, this, ERR_FILE_NOT_FOUND));
     return;
   }
 
   int types = base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES;
   if (!recursive_)
     types |= base::FileEnumerator::INCLUDE_DOT_DOT;
@@ skipping 19 matching lines @@
 
     origin_loop_->PostTask(
         FROM_HERE,
         base::Bind(&DirectoryLister::Core::SendData, file_data));
     file_data.clear();
     */
   }
 
   SortData(&file_data, sort_);
   origin_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&DirectoryLister::Core::SendData, this, file_data));
+      FROM_HERE, base::Bind(&DirectoryLister::Core::SendData, this, file_data));
 
-  origin_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&DirectoryLister::Core::OnDone, this, OK));
+  origin_loop_->PostTask(FROM_HERE,
+                         base::Bind(&DirectoryLister::Core::OnDone, this, OK));
 }
 
 void DirectoryLister::Core::SendData(
     const std::vector<DirectoryLister::DirectoryListerData>& data) {
   DCHECK(origin_loop_->BelongsToCurrentThread());
   // We need to check for cancellation (indicated by NULL'ing of |lister_|)
   // which can happen during each callback.
   for (size_t i = 0; lister_ && i < data.size(); ++i)
     lister_->OnReceivedData(data[i]);
 }
 
 void DirectoryLister::Core::OnDone(int error) {
   DCHECK(origin_loop_->BelongsToCurrentThread());
   if (lister_)
     lister_->OnDone(error);
 }
 
 void DirectoryLister::OnReceivedData(const DirectoryListerData& data) {
   delegate_->OnListFile(data);
 }
 
 void DirectoryLister::OnDone(int error) {
   delegate_->OnListDone(error);
 }
 
 }  // namespace net