net: Rename FileStream::Open/Close with OpenSync/CloseSync.

chrome/browser/sessions/session_backend.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 "chrome/browser/sessions/session_backend.h"
 
 #include <limits>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 30 matching lines @@
   typedef SessionCommand::id_type id_type;
   typedef SessionCommand::size_type size_type;
 
   explicit SessionFileReader(const FilePath& path)
       : errored_(false),
         buffer_(SessionBackend::kFileReadBufferSize, 0),
         buffer_position_(0),
         available_count_(0) {
     file_.reset(new net::FileStream(NULL));
     if (file_util::PathExists(path))
-      file_->Open(path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
+      file_->OpenSync(path,
+                      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   }
   // Reads the contents of the file specified in the constructor, returning
   // true on success. It is up to the caller to free all SessionCommands
   // added to commands.
   bool Read(BaseSessionService::SessionType type,
             std::vector<SessionCommand*>* commands);
 
  private:
   // Reads a single command, returning it. A return value of NULL indicates
   // either there are no commands, or there was an error. Use errored_ to
@@ skipping 278 matching lines @@
     }
   }
   file->Flush();
   return true;
 }
 
 SessionBackend::~SessionBackend() {
   if (current_session_file_.get()) {
     // Close() performs file IO. crbug.com/112512.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
-    current_session_file_->Close();
+    current_session_file_->CloseSync();
   }
 }
 
 void SessionBackend::ResetFile() {
   DCHECK(inited_);
   if (current_session_file_.get()) {
     // File is already open, truncate it. We truncate instead of closing and
     // reopening to avoid the possibility of scanners locking the file out
     // from under us once we close it. If truncation fails, we'll try to
     // recreate.
     const int header_size = static_cast<int>(sizeof(FileHeader));
     if (current_session_file_->Truncate(header_size) != header_size)
       current_session_file_.reset(NULL);
   }
   if (!current_session_file_.get())
     current_session_file_.reset(OpenAndWriteHeader(GetCurrentSessionPath()));
   empty_file_ = true;
 }
 
 net::FileStream* SessionBackend::OpenAndWriteHeader(const FilePath& path) {
   DCHECK(!path.empty());
   scoped_ptr<net::FileStream> file(new net::FileStream(NULL));
-  if (file->Open(path, base::PLATFORM_FILE_CREATE_ALWAYS |
+  if (file->OpenSync(path, base::PLATFORM_FILE_CREATE_ALWAYS |
       base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
       base::PLATFORM_FILE_EXCLUSIVE_READ) != net::OK)
     return NULL;
   FileHeader header;
   header.signature = kFileSignature;
   header.version = kFileCurrentVersion;
   int wrote = file->Write(reinterpret_cast<char*>(&header),
                           sizeof(header), net::CompletionCallback());
   if (wrote != sizeof(header))
     return NULL;
@@ skipping 10 matching lines @@
 }
 
 FilePath SessionBackend::GetCurrentSessionPath() {
   FilePath path = path_to_dir_;
   if (type_ == BaseSessionService::TAB_RESTORE)
     path = path.AppendASCII(kCurrentTabSessionFileName);
   else
     path = path.AppendASCII(kCurrentSessionFileName);
   return path;
 }