Disk cache: Reference CL for the implementation of file format version 3.

net/disk_cache/file_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/disk_cache/file.h"
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "net/base/net_errors.h"
@@ skipping 26 matching lines @@
 static base::LazyInstance<CompletionHandler> g_completion_handler =
     LAZY_INSTANCE_INITIALIZER;
 
 void CompletionHandler::OnIOCompleted(MessageLoopForIO::IOContext* context,
                                       DWORD actual_bytes, DWORD error) {
   MyOverlapped* data = reinterpret_cast<MyOverlapped*>(context);
 
   if (error) {
     DCHECK(!actual_bytes);
     actual_bytes = static_cast<DWORD>(net::ERR_CACHE_READ_FAILURE);
-    NOTREACHED();
   }
 
   if (data->callback_)
     data->callback_->OnFileIOComplete(static_cast<int>(actual_bytes));
 
   delete data;
 }
 
 MyOverlapped::MyOverlapped(disk_cache::File* file, size_t offset,
                            disk_cache::FileIOCallback* callback) {
   memset(this, 0, sizeof(*this));
   context_.handler = g_completion_handler.Pointer();
   context_.overlapped.Offset = static_cast<DWORD>(offset);
   file_ = file;
   callback_ = callback;
 }
 
 }  // namespace
 
 namespace disk_cache {
 
 File::File(base::PlatformFile file)
-    : init_(true), mixed_(true), platform_file_(INVALID_HANDLE_VALUE),
+    : init_(true),
+      mixed_(true),
+      force_creation_(false),
+      platform_file_(INVALID_HANDLE_VALUE),
       sync_platform_file_(file) {
 }
 
 bool File::Init(const base::FilePath& name) {
   DCHECK(!init_);
   if (init_)
     return false;
 
   DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
   DWORD access = GENERIC_READ | GENERIC_WRITE | DELETE;
+  DWORD mode = force_creation_ ? OPEN_ALWAYS : OPEN_EXISTING;
   platform_file_ = CreateFile(name.value().c_str(), access, sharing, NULL,
-                              OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+                              mode, FILE_FLAG_OVERLAPPED, NULL);
 
   if (INVALID_HANDLE_VALUE == platform_file_)
     return false;
 
   MessageLoopForIO::current()->RegisterIOHandler(
       platform_file_, g_completion_handler.Pointer());
 
   init_ = true;
   sync_platform_file_  = CreateFile(name.value().c_str(), access, sharing, NULL,
                                     OPEN_EXISTING, 0, NULL);
@@ skipping 170 matching lines @@
     MessageLoopForIO::current()->WaitForIOCompletion(100, handler);
   }
 }
 
 // Static.
 void File::DropPendingIO() {
   // Nothing to do here.
 }
 
 }  // namespace disk_cache