OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "webkit/browser/fileapi/file_system_file_stream_reader.h" | 5 #include "storage/browser/fileapi/file_system_file_stream_reader.h" |
6 | 6 |
7 #include "base/files/file_util_proxy.h" | 7 #include "base/files/file_util_proxy.h" |
8 #include "base/single_thread_task_runner.h" | 8 #include "base/single_thread_task_runner.h" |
9 #include "net/base/file_stream.h" | 9 #include "net/base/file_stream.h" |
10 #include "net/base/io_buffer.h" | 10 #include "net/base/io_buffer.h" |
11 #include "net/base/net_errors.h" | 11 #include "net/base/net_errors.h" |
12 #include "webkit/browser/blob/file_stream_reader.h" | 12 #include "storage/browser/blob/file_stream_reader.h" |
13 #include "webkit/browser/fileapi/file_system_context.h" | 13 #include "storage/browser/fileapi/file_system_context.h" |
14 #include "webkit/browser/fileapi/file_system_operation_runner.h" | 14 #include "storage/browser/fileapi/file_system_operation_runner.h" |
15 | 15 |
16 using webkit_blob::FileStreamReader; | 16 using storage::FileStreamReader; |
17 | 17 |
18 // TODO(kinuko): Remove this temporary namespace hack after we move both | 18 // TODO(kinuko): Remove this temporary namespace hack after we move both |
19 // blob and fileapi into content namespace. | 19 // blob and fileapi into content namespace. |
20 namespace webkit_blob { | 20 namespace storage { |
21 | 21 |
22 FileStreamReader* FileStreamReader::CreateForFileSystemFile( | 22 FileStreamReader* FileStreamReader::CreateForFileSystemFile( |
23 fileapi::FileSystemContext* file_system_context, | 23 storage::FileSystemContext* file_system_context, |
24 const fileapi::FileSystemURL& url, | 24 const storage::FileSystemURL& url, |
25 int64 initial_offset, | 25 int64 initial_offset, |
26 const base::Time& expected_modification_time) { | 26 const base::Time& expected_modification_time) { |
27 return new fileapi::FileSystemFileStreamReader( | 27 return new storage::FileSystemFileStreamReader( |
28 file_system_context, | 28 file_system_context, url, initial_offset, expected_modification_time); |
29 url, | |
30 initial_offset, | |
31 expected_modification_time); | |
32 } | 29 } |
33 | 30 |
34 } // namespace webkit_blob | 31 } // namespace storage |
35 | 32 |
36 namespace fileapi { | 33 namespace storage { |
37 | 34 |
38 namespace { | 35 namespace { |
39 | 36 |
40 void ReadAdapter(base::WeakPtr<FileSystemFileStreamReader> reader, | 37 void ReadAdapter(base::WeakPtr<FileSystemFileStreamReader> reader, |
41 net::IOBuffer* buf, int buf_len, | 38 net::IOBuffer* buf, |
| 39 int buf_len, |
42 const net::CompletionCallback& callback) { | 40 const net::CompletionCallback& callback) { |
43 if (!reader.get()) | 41 if (!reader.get()) |
44 return; | 42 return; |
45 int rv = reader->Read(buf, buf_len, callback); | 43 int rv = reader->Read(buf, buf_len, callback); |
46 if (rv != net::ERR_IO_PENDING) | 44 if (rv != net::ERR_IO_PENDING) |
47 callback.Run(rv); | 45 callback.Run(rv); |
48 } | 46 } |
49 | 47 |
50 void GetLengthAdapter(base::WeakPtr<FileSystemFileStreamReader> reader, | 48 void GetLengthAdapter(base::WeakPtr<FileSystemFileStreamReader> reader, |
51 const net::Int64CompletionCallback& callback) { | 49 const net::Int64CompletionCallback& callback) { |
52 if (!reader.get()) | 50 if (!reader.get()) |
53 return; | 51 return; |
54 int rv = reader->GetLength(callback); | 52 int rv = reader->GetLength(callback); |
55 if (rv != net::ERR_IO_PENDING) | 53 if (rv != net::ERR_IO_PENDING) |
56 callback.Run(rv); | 54 callback.Run(rv); |
57 } | 55 } |
58 | 56 |
59 void Int64CallbackAdapter(const net::Int64CompletionCallback& callback, | 57 void Int64CallbackAdapter(const net::Int64CompletionCallback& callback, |
60 int value) { | 58 int value) { |
61 callback.Run(value); | 59 callback.Run(value); |
62 } | 60 } |
63 | 61 |
64 } // namespace | 62 } // namespace |
65 | 63 |
66 FileSystemFileStreamReader::~FileSystemFileStreamReader() { | 64 FileSystemFileStreamReader::~FileSystemFileStreamReader() { |
67 } | 65 } |
68 | 66 |
69 int FileSystemFileStreamReader::Read( | 67 int FileSystemFileStreamReader::Read(net::IOBuffer* buf, |
70 net::IOBuffer* buf, int buf_len, | 68 int buf_len, |
71 const net::CompletionCallback& callback) { | 69 const net::CompletionCallback& callback) { |
72 if (local_file_reader_) | 70 if (local_file_reader_) |
73 return local_file_reader_->Read(buf, buf_len, callback); | 71 return local_file_reader_->Read(buf, buf_len, callback); |
74 return CreateSnapshot( | 72 return CreateSnapshot(base::Bind(&ReadAdapter, |
75 base::Bind(&ReadAdapter, weak_factory_.GetWeakPtr(), | 73 weak_factory_.GetWeakPtr(), |
76 make_scoped_refptr(buf), buf_len, callback), | 74 make_scoped_refptr(buf), |
77 callback); | 75 buf_len, |
| 76 callback), |
| 77 callback); |
78 } | 78 } |
79 | 79 |
80 int64 FileSystemFileStreamReader::GetLength( | 80 int64 FileSystemFileStreamReader::GetLength( |
81 const net::Int64CompletionCallback& callback) { | 81 const net::Int64CompletionCallback& callback) { |
82 if (local_file_reader_) | 82 if (local_file_reader_) |
83 return local_file_reader_->GetLength(callback); | 83 return local_file_reader_->GetLength(callback); |
84 return CreateSnapshot( | 84 return CreateSnapshot( |
85 base::Bind(&GetLengthAdapter, weak_factory_.GetWeakPtr(), callback), | 85 base::Bind(&GetLengthAdapter, weak_factory_.GetWeakPtr(), callback), |
86 base::Bind(&Int64CallbackAdapter, callback)); | 86 base::Bind(&Int64CallbackAdapter, callback)); |
87 } | 87 } |
(...skipping 24 matching lines...) Expand all Loading... |
112 error_callback)); | 112 error_callback)); |
113 return net::ERR_IO_PENDING; | 113 return net::ERR_IO_PENDING; |
114 } | 114 } |
115 | 115 |
116 void FileSystemFileStreamReader::DidCreateSnapshot( | 116 void FileSystemFileStreamReader::DidCreateSnapshot( |
117 const base::Closure& callback, | 117 const base::Closure& callback, |
118 const net::CompletionCallback& error_callback, | 118 const net::CompletionCallback& error_callback, |
119 base::File::Error file_error, | 119 base::File::Error file_error, |
120 const base::File::Info& file_info, | 120 const base::File::Info& file_info, |
121 const base::FilePath& platform_path, | 121 const base::FilePath& platform_path, |
122 const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) { | 122 const scoped_refptr<storage::ShareableFileReference>& file_ref) { |
123 DCHECK(has_pending_create_snapshot_); | 123 DCHECK(has_pending_create_snapshot_); |
124 DCHECK(!local_file_reader_.get()); | 124 DCHECK(!local_file_reader_.get()); |
125 has_pending_create_snapshot_ = false; | 125 has_pending_create_snapshot_ = false; |
126 | 126 |
127 if (file_error != base::File::FILE_OK) { | 127 if (file_error != base::File::FILE_OK) { |
128 error_callback.Run(net::FileErrorToNetError(file_error)); | 128 error_callback.Run(net::FileErrorToNetError(file_error)); |
129 return; | 129 return; |
130 } | 130 } |
131 | 131 |
132 // Keep the reference (if it's non-null) so that the file won't go away. | 132 // Keep the reference (if it's non-null) so that the file won't go away. |
133 snapshot_ref_ = file_ref; | 133 snapshot_ref_ = file_ref; |
134 | 134 |
135 local_file_reader_.reset( | 135 local_file_reader_.reset(FileStreamReader::CreateForLocalFile( |
136 FileStreamReader::CreateForLocalFile( | 136 file_system_context_->default_file_task_runner(), |
137 file_system_context_->default_file_task_runner(), | 137 platform_path, |
138 platform_path, initial_offset_, expected_modification_time_)); | 138 initial_offset_, |
| 139 expected_modification_time_)); |
139 | 140 |
140 callback.Run(); | 141 callback.Run(); |
141 } | 142 } |
142 | 143 |
143 } // namespace fileapi | 144 } // namespace storage |
OLD | NEW |