Clang format slam.

net/tools/dump_cache/upgrade_win.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/tools/dump_cache/upgrade_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 16 matching lines @@
 
 namespace {
 
 const wchar_t kPipePrefix[] = L"\\\\.\\pipe\\dump_cache_";
 const int kChannelSize = 64 * 1024;
 const int kNumStreams = 4;
 
 // Simple macro to print out formatted debug messages. It is similar to a DLOG
 // except that it doesn't include a header.
 #ifdef NDEBUG
-#define DEBUGMSG(...) {}
+#define DEBUGMSG(...) \
+  {}
 #else
-#define DEBUGMSG(...) { printf(__VA_ARGS__); }
+#define DEBUGMSG(...) \
+  { printf(__VA_ARGS__); }
 #endif
 
 HANDLE OpenServer(const base::string16& pipe_number) {
   base::string16 pipe_name(kPipePrefix);
   pipe_name.append(pipe_number);
-  return CreateFile(pipe_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL,
-                    OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+  return CreateFile(pipe_name.c_str(),
+                    GENERIC_READ | GENERIC_WRITE,
+                    0,
+                    NULL,
+                    OPEN_EXISTING,
+                    FILE_FLAG_OVERLAPPED,
+                    NULL);
 }
 
 // This is the basic message to use between the two processes. It is intended
 // to transmit a single action (like "get the key name for entry xx"), with up
 // to 5 32-bit arguments and 4 64-bit arguments. After this structure, the rest
 // of the message has |buffer_bytes| of length with the actual data.
 struct Message {
   int32 command;
   int32 result;
   int32 buffer_bytes;
   int32 arg1;
   int32 arg2;
   int32 arg3;
   int32 arg4;
   int32 arg5;
   int64 long_arg1;
   int64 long_arg2;
   int64 long_arg3;
   int64 long_arg4;
-  Message() {
-    memset(this, 0, sizeof(*this));
-  }
-  Message& operator= (const Message& other) {
+  Message() { memset(this, 0, sizeof(*this)); }
+  Message& operator=(const Message& other) {
     memcpy(this, &other, sizeof(*this));
     return *this;
   }
 };
 
 const int kBufferSize = kChannelSize - sizeof(Message);
 struct IoBuffer {
   Message msg;
   char buffer[kBufferSize];
 };
 COMPILE_ASSERT(sizeof(IoBuffer) == kChannelSize, invalid_io_buffer);
 
-
 // The list of commands.
 // Currently, there is support for working ONLY with one entry at a time.
 enum {
   // Get the entry from list |arg1| that follows |long_arg1|.
   // The result is placed on |long_arg1| (closes the previous one).
   GET_NEXT_ENTRY = 1,
   // Get the entry from list |arg1| that precedes |long_arg1|.
   // The result is placed on |long_arg1| (closes the previous one).
   GET_PREV_ENTRY,
   // Closes the entry |long_arg1|.
@@ skipping 44 matching lines @@
   scoped_ptr<char[]> in_buffer_;
   scoped_ptr<char[]> out_buffer_;
   IoBuffer* input_;
   IoBuffer* output_;
   base::Thread cache_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseSM);
 };
 
 BaseSM::BaseSM(HANDLE channel)
-      : entry_(NULL), channel_(channel), state_(0), pending_count_(0),
-        cache_thread_("cache") {
+    : entry_(NULL),
+      channel_(channel),
+      state_(0),
+      pending_count_(0),
+      cache_thread_("cache") {
   in_buffer_.reset(new char[kChannelSize]);
   out_buffer_.reset(new char[kChannelSize]);
   input_ = reinterpret_cast<IoBuffer*>(in_buffer_.get());
   output_ = reinterpret_cast<IoBuffer*>(out_buffer_.get());
 
   memset(&in_context_, 0, sizeof(in_context_));
   memset(&out_context_, 0, sizeof(out_context_));
   in_context_.handler = this;
   out_context_.handler = this;
   base::MessageLoopForIO::current()->RegisterIOHandler(channel_, this);
   CHECK(cache_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 }
 
 BaseSM::~BaseSM() {
   if (entry_)
     entry_->Close();
 }
 
 bool BaseSM::SendMsg(const Message& msg) {
   // Only one command will be in-flight at a time. Let's start the Read IO here
   // when we know that it will be pending.
   if (!ReceiveMsg())
     return false;
 
   output_->msg = msg;
   DWORD written;
-  if (!WriteFile(channel_, output_, sizeof(msg) + msg.buffer_bytes, &written,
+  if (!WriteFile(channel_,
+                 output_,
+                 sizeof(msg) + msg.buffer_bytes,
+                 &written,
                  &out_context_.overlapped)) {
     if (ERROR_IO_PENDING != GetLastError())
       return false;
   }
   pending_count_++;
   return true;
 }
 
 bool BaseSM::ReceiveMsg() {
   DWORD read;
-  if (!ReadFile(channel_, input_, kChannelSize, &read,
-                &in_context_.overlapped)) {
+  if (!ReadFile(
+          channel_, input_, kChannelSize, &read, &in_context_.overlapped)) {
     if (ERROR_IO_PENDING != GetLastError())
       return false;
   }
   pending_count_++;
   return true;
 }
 
 bool BaseSM::ConnectChannel() {
   if (!ConnectNamedPipe(channel_, &in_context_.overlapped)) {
     DWORD error = GetLastError();
@@ skipping 10 matching lines @@
 
 bool BaseSM::IsPending() {
   return pending_count_ != 0;
 }
 
 // -----------------------------------------------------------------------
 
 class MasterSM : public BaseSM {
  public:
   MasterSM(const base::FilePath& path, HANDLE channel)
-      : BaseSM(channel),
-        path_(path) {
-  }
-  virtual ~MasterSM() {
-    delete writer_;
-  }
+      : BaseSM(channel), path_(path) {}
+  virtual ~MasterSM() { delete writer_; }
 
   bool DoInit();
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered,
                              DWORD error);
 
  private:
   enum {
     MASTER_INITIAL = 0,
     MASTER_CONNECT,
@@ skipping 80 matching lines @@
   }
 }
 
 bool MasterSM::DoInit() {
   DEBUGMSG("Master DoInit\n");
   DCHECK(state_ == MASTER_INITIAL);
 
   scoped_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback cb;
   int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                          net::CACHE_BACKEND_DEFAULT, path_, 0,
+                                          net::CACHE_BACKEND_DEFAULT,
+                                          path_,
+                                          0,
                                           false,
                                           cache_thread_.message_loop_proxy(),
-                                          NULL, &cache, cb.callback());
+                                          NULL,
+                                          &cache,
+                                          cb.callback());
   if (cb.GetResult(rv) != net::OK) {
     printf("Unable to initialize new files\n");
     return false;
   }
   cache_ = cache.Pass();
   writer_ = new CacheDumper(cache_.get());
 
   copied_entries_ = 0;
   remote_entry_ = 0;
 
@@ skipping 45 matching lines @@
     return SendGetPrevEntry();
   }
 
   if (input_->msg.result != RESULT_OK)
     return Fail();
 
   std::string key(input_->buffer);
   DCHECK(key.size() == static_cast<size_t>(input_->msg.buffer_bytes - 1));
 
   int rv = writer_->CreateEntry(
-      key, reinterpret_cast<disk_cache::Entry**>(&entry_),
+      key,
+      reinterpret_cast<disk_cache::Entry**>(&entry_),
       base::Bind(&MasterSM::DoCreateEntryComplete, base::Unretained(this)));
 
   if (rv != net::ERR_IO_PENDING)
     DoCreateEntryComplete(rv);
 }
 
 void MasterSM::DoCreateEntryComplete(int result) {
   std::string key(input_->buffer);
   if (result != net::OK) {
     printf("Skipping entry \"%s\": %d\n", key.c_str(), GetLastError());
@@ skipping 57 matching lines @@
   DEBUGMSG("Master CloseEntry\n");
   printf("%c\r", copied_entries_ % 2 ? 'x' : '+');
   writer_->CloseEntry(entry_, last_used_, last_modified_);
   entry_ = NULL;
   copied_entries_++;
   SendGetPrevEntry();
 }
 
 void MasterSM::SendReadData() {
   int read_size = std::min(bytes_remaining_, kBufferSize);
-  DEBUGMSG("Master SendReadData (%d): %d bytes at %d\n", stream_, read_size,
+  DEBUGMSG("Master SendReadData (%d): %d bytes at %d\n",
+           stream_,
+           read_size,
            offset_);
   if (bytes_remaining_ <= 0) {
     stream_++;
     if (stream_ >= kNumStreams)
       return CloseEntry();
     return SendGetDataSize();
   }
 
   state_ = MASTER_READ_DATA;
   Message msg;
@@ skipping 15 matching lines @@
   int read_size = input_->msg.buffer_bytes;
   if (!read_size) {
     printf("Read failed, entry \"%s\" truncated!\n", entry_->GetKey().c_str());
     bytes_remaining_ = 0;
     return SendReadData();
   }
 
   scoped_refptr<net::WrappedIOBuffer> buf =
       new net::WrappedIOBuffer(input_->buffer);
   int rv = writer_->WriteEntry(
-      entry_, stream_, offset_, buf, read_size,
+      entry_,
+      stream_,
+      offset_,
+      buf,
+      read_size,
       base::Bind(&MasterSM::DoReadDataComplete, base::Unretained(this)));
   if (rv == net::ERR_IO_PENDING) {
     // We'll continue in DoReadDataComplete.
     read_size_ = read_size;
     return;
   }
 
   if (rv <= 0)
     return Fail();
 
@@ skipping 41 matching lines @@
  public:
   SlaveSM(const base::FilePath& path, HANDLE channel);
   virtual ~SlaveSM();
 
   bool DoInit();
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered,
                              DWORD error);
 
  private:
-  enum {
-    SLAVE_INITIAL = 0,
-    SLAVE_WAITING,
-    SLAVE_END
-  };
+  enum { SLAVE_INITIAL = 0, SLAVE_WAITING, SLAVE_END };
 
   void DoGetNextEntry();
   void DoGetPrevEntry();
   int32 GetEntryFromList();
   void DoGetEntryComplete(int result);
   void DoCloseEntry();
   void DoGetKey();
   void DoGetUseTimes();
   void DoGetDataSize();
   void DoReadData();
   void DoReadDataComplete(int ret);
   void DoEnd();
   void Fail();
 
   void* iterator_;
   Message msg_;  // Used for DoReadDataComplete and DoGetEntryComplete.
 
   scoped_ptr<disk_cache::BackendImpl> cache_;
 };
 
 SlaveSM::SlaveSM(const base::FilePath& path, HANDLE channel)
     : BaseSM(channel), iterator_(NULL) {
   scoped_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback cb;
   int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                          net::CACHE_BACKEND_BLOCKFILE, path, 0,
+                                          net::CACHE_BACKEND_BLOCKFILE,
+                                          path,
+                                          0,
                                           false,
                                           cache_thread_.message_loop_proxy(),
-                                          NULL, &cache, cb.callback());
+                                          NULL,
+                                          &cache,
+                                          cb.callback());
   if (cb.GetResult(rv) != net::OK) {
     printf("Unable to open cache files\n");
     return;
   }
   cache_.reset(reinterpret_cast<disk_cache::BackendImpl*>(cache.release()));
   cache_->SetUpgradeMode();
 }
 
 SlaveSM::~SlaveSM() {
   if (iterator_)
@@ skipping 105 matching lines @@
   if (input_->msg.long_arg1 != reinterpret_cast<int64>(entry_))
     return RESULT_INVALID_PARAMETER;
 
   // We know that the current iteration is valid.
   if (entry_)
     entry_->Close();
 
   int rv;
   if (input_->msg.command == GET_NEXT_ENTRY) {
     rv = cache_->OpenNextEntry(
-        &iterator_, reinterpret_cast<disk_cache::Entry**>(&entry_),
+        &iterator_,
+        reinterpret_cast<disk_cache::Entry**>(&entry_),
         base::Bind(&SlaveSM::DoGetEntryComplete, base::Unretained(this)));
   } else {
     DCHECK(input_->msg.command == GET_PREV_ENTRY);
-    rv = cache_->OpenPrevEntry(&iterator_,
-                               reinterpret_cast<disk_cache::Entry**>(&entry_),
-                               base::Bind(&SlaveSM::DoGetEntryComplete,
-                                          base::Unretained(this)));
+    rv = cache_->OpenPrevEntry(
+        &iterator_,
+        reinterpret_cast<disk_cache::Entry**>(&entry_),
+        base::Bind(&SlaveSM::DoGetEntryComplete, base::Unretained(this)));
   }
   DCHECK_EQ(net::ERR_IO_PENDING, rv);
   return RESULT_PENDING;
 }
 
 void SlaveSM::DoGetEntryComplete(int result) {
   DEBUGMSG("\t\t\tSlave DoGetEntryComplete\n");
   if (result != net::OK) {
     entry_ = NULL;
     DEBUGMSG("\t\t\tSlave end of list\n");
   }
 
   msg_.result = RESULT_OK;
   msg_.long_arg1 = reinterpret_cast<int64>(entry_);
   SendMsg(msg_);
 }
 
 void SlaveSM::DoCloseEntry() {
   DEBUGMSG("\t\t\tSlave DoCloseEntry\n");
   Message msg;
   msg.command = GET_KEY;
 
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) {
-    msg.result =  RESULT_INVALID_PARAMETER;
+    msg.result = RESULT_INVALID_PARAMETER;
   } else {
     entry_->Close();
     entry_ = NULL;
     cache_->EndEnumeration(&iterator_);
     msg.result = RESULT_OK;
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoGetKey() {
   DEBUGMSG("\t\t\tSlave DoGetKey\n");
   Message msg;
   msg.command = GET_KEY;
 
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) {
-    msg.result =  RESULT_INVALID_PARAMETER;
+    msg.result = RESULT_INVALID_PARAMETER;
   } else {
     std::string key = entry_->GetKey();
-    msg.buffer_bytes = std::min(key.size() + 1,
-                                static_cast<size_t>(kBufferSize));
+    msg.buffer_bytes =
+        std::min(key.size() + 1, static_cast<size_t>(kBufferSize));
     memcpy(output_->buffer, key.c_str(), msg.buffer_bytes);
     if (msg.buffer_bytes != static_cast<int32>(key.size() + 1)) {
       // We don't support moving this entry. Just tell the master.
       msg.result = RESULT_NAME_OVERFLOW;
     } else {
       msg.result = RESULT_OK;
     }
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoGetUseTimes() {
   DEBUGMSG("\t\t\tSlave DoGetUseTimes\n");
   Message msg;
   msg.command = GET_USE_TIMES;
 
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) {
-    msg.result =  RESULT_INVALID_PARAMETER;
+    msg.result = RESULT_INVALID_PARAMETER;
   } else {
     msg.long_arg2 = entry_->GetLastUsed().ToInternalValue();
     msg.long_arg3 = entry_->GetLastModified().ToInternalValue();
     msg.result = RESULT_OK;
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoGetDataSize() {
   DEBUGMSG("\t\t\tSlave DoGetDataSize\n");
   Message msg;
   msg.command = GET_DATA_SIZE;
 
   int stream = input_->msg.arg1;
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_) ||
       stream < 0 || stream >= kNumStreams) {
-    msg.result =  RESULT_INVALID_PARAMETER;
+    msg.result = RESULT_INVALID_PARAMETER;
   } else {
     msg.arg1 = stream;
     msg.arg2 = entry_->GetDataSize(stream);
     msg.result = RESULT_OK;
   }
   SendMsg(msg);
 }
 
 void SlaveSM::DoReadData() {
   DEBUGMSG("\t\t\tSlave DoReadData\n");
   Message msg;
   msg.command = READ_DATA;
 
   int stream = input_->msg.arg1;
   int size = input_->msg.arg2;
   if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_) ||
       stream < 0 || stream > 1 || size > kBufferSize) {
-    msg.result =  RESULT_INVALID_PARAMETER;
+    msg.result = RESULT_INVALID_PARAMETER;
   } else {
     scoped_refptr<net::WrappedIOBuffer> buf =
         new net::WrappedIOBuffer(output_->buffer);
-    int ret = entry_->ReadData(stream, input_->msg.arg3, buf, size,
-                               base::Bind(&SlaveSM::DoReadDataComplete,
-                                          base::Unretained(this)));
+    int ret = entry_->ReadData(
+        stream,
+        input_->msg.arg3,
+        buf,
+        size,
+        base::Bind(&SlaveSM::DoReadDataComplete, base::Unretained(this)));
     if (ret == net::ERR_IO_PENDING) {
       // Save the message so we can continue were we left.
       msg_ = msg;
       return;
     }
 
     msg.buffer_bytes = (ret < 0) ? 0 : ret;
     msg.result = RESULT_OK;
   }
   SendMsg(msg);
@@ skipping 27 matching lines @@
 }  // namespace.
 
 // -----------------------------------------------------------------------
 
 HANDLE CreateServer(base::string16* pipe_number) {
   base::string16 pipe_name(kPipePrefix);
   srand(static_cast<int>(base::Time::Now().ToInternalValue()));
   *pipe_number = base::IntToString16(rand());
   pipe_name.append(*pipe_number);
 
-  DWORD mode = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE |
-               FILE_FLAG_OVERLAPPED;
+  DWORD mode =
+      PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED;
 
-  return CreateNamedPipe(pipe_name.c_str(), mode, 0, 1, kChannelSize,
-                         kChannelSize, 0, NULL);
+  return CreateNamedPipe(
+      pipe_name.c_str(), mode, 0, 1, kChannelSize, kChannelSize, 0, NULL);
 }
 
 // This is the controller process for an upgrade operation.
 int UpgradeCache(const base::FilePath& output_path, HANDLE pipe) {
   base::MessageLoopForIO loop;
 
   MasterSM master(output_path, pipe);
   if (!master.DoInit()) {
     printf("Unable to talk with the helper\n");
     return -1;
@@ skipping 16 matching lines @@
 
   SlaveSM slave(input_path, pipe);
   if (!slave.DoInit()) {
     printf("Unable to talk with the main process\n");
     return -1;
   }
 
   loop.Run();
   return 0;
 }