IndexedDB: Fixed support for empty blobs.

storage/browser/fileapi/local_file_stream_writer.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 "storage/browser/fileapi/local_file_stream_writer.h"
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/profiler/scoped_tracker.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace storage {
 
 namespace {
 
 const int kOpenFlagsForWrite = base::File::FLAG_OPEN |
                                base::File::FLAG_WRITE |
                                base::File::FLAG_ASYNC;
-const int kCreateFlagsForWrite = base::File::FLAG_CREATE |
-                                 base::File::FLAG_WRITE |
-                                 base::File::FLAG_ASYNC;
 
 }  // namespace
 
 FileStreamWriter* FileStreamWriter::CreateForLocalFile(
     base::TaskRunner* task_runner,
     const base::FilePath& file_path,
-    int64 initial_offset,
-    OpenOrCreate open_or_create) {
-  return new LocalFileStreamWriter(
-      task_runner, file_path, initial_offset, open_or_create);
+    int64 initial_offset) {
+  return new LocalFileStreamWriter(task_runner, file_path, initial_offset);
 }
 
 LocalFileStreamWriter::~LocalFileStreamWriter() {
   // Invalidate weak pointers so that we won't receive any callbacks from
   // in-flight stream operations, which might be triggered during the file close
   // in the FileStream destructor.
   weak_factory_.InvalidateWeakPtrs();
 
   // FileStream's destructor closes the file safely, since we opened the file
   // by its Open() method.
@@ skipping 36 matching lines @@
 
   has_pending_operation_ = true;
   int result = InitiateFlush(callback);
   if (result != net::ERR_IO_PENDING)
     has_pending_operation_ = false;
   return result;
 }
 
 LocalFileStreamWriter::LocalFileStreamWriter(base::TaskRunner* task_runner,
                                              const base::FilePath& file_path,
-                                             int64 initial_offset,
-                                             OpenOrCreate open_or_create)
+                                             int64 initial_offset)
     : file_path_(file_path),
-      open_or_create_(open_or_create),
       initial_offset_(initial_offset),
       task_runner_(task_runner),
       has_pending_operation_(false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 int LocalFileStreamWriter::InitiateOpen(
     const net::CompletionCallback& error_callback,
     const base::Closure& main_operation) {
   DCHECK(has_pending_operation_);
   DCHECK(!stream_impl_.get());
 
   stream_impl_.reset(new net::FileStream(task_runner_));
 
-  int open_flags = 0;
-  switch (open_or_create_) {
-  case OPEN_EXISTING_FILE:
-    open_flags = kOpenFlagsForWrite;
-    break;
-  case CREATE_NEW_FILE:
-    open_flags = kCreateFlagsForWrite;
-    break;
-  }
-
-  return stream_impl_->Open(file_path_,
-                            open_flags,
-                            base::Bind(&LocalFileStreamWriter::DidOpen,
-                                       weak_factory_.GetWeakPtr(),
-                                       error_callback,
-                                       main_operation));
+  return stream_impl_->Open(
+      file_path_, kOpenFlagsForWrite,
+      base::Bind(&LocalFileStreamWriter::DidOpen, weak_factory_.GetWeakPtr(),
+                 error_callback, main_operation));
 }
 
 void LocalFileStreamWriter::DidOpen(
     const net::CompletionCallback& error_callback,
     const base::Closure& main_operation,
     int result) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "423948 LocalFileStreamWriter::DidOpen"));
@@ skipping 121 matching lines @@
     return false;
 
   net::CompletionCallback pending_cancel = cancel_callback_;
   has_pending_operation_ = false;
   cancel_callback_.Reset();
   pending_cancel.Run(net::OK);
   return true;
 }
 
 }  // namespace storage