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/glue/resource_request_body.h" | 5 #include "webkit/glue/resource_request_body.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "net/base/upload_bytes_element_reader.h" | 8 #include "net/base/upload_bytes_element_reader.h" |
9 #include "net/base/upload_data_stream.h" | 9 #include "net/base/upload_data_stream.h" |
10 #include "net/base/upload_file_element_reader.h" | 10 #include "net/base/upload_file_element_reader.h" |
11 #include "webkit/blob/blob_storage_controller.h" | 11 #include "webkit/blob/blob_storage_context.h" |
12 #include "webkit/fileapi/upload_file_system_file_element_reader.h" | 12 #include "webkit/fileapi/upload_file_system_file_element_reader.h" |
13 | 13 |
14 using webkit_blob::BlobData; | 14 using webkit_blob::BlobData; |
15 using webkit_blob::BlobStorageController; | 15 using webkit_blob::BlobStorageContext; |
16 | 16 |
17 namespace webkit_glue { | 17 namespace webkit_glue { |
18 | 18 |
19 namespace { | 19 namespace { |
20 | 20 |
21 // A subclass of net::UploadBytesElementReader which owns ResourceRequestBody. | 21 // A subclass of net::UploadBytesElementReader which owns ResourceRequestBody. |
22 class BytesElementReader : public net::UploadBytesElementReader { | 22 class BytesElementReader : public net::UploadBytesElementReader { |
23 public: | 23 public: |
24 BytesElementReader(ResourceRequestBody* resource_request_body, | 24 BytesElementReader(ResourceRequestBody* resource_request_body, |
25 const ResourceRequestBody::Element& element) | 25 const ResourceRequestBody::Element& element) |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
74 | 74 |
75 void ResourceRequestBody::AppendFileRange( | 75 void ResourceRequestBody::AppendFileRange( |
76 const base::FilePath& file_path, | 76 const base::FilePath& file_path, |
77 uint64 offset, uint64 length, | 77 uint64 offset, uint64 length, |
78 const base::Time& expected_modification_time) { | 78 const base::Time& expected_modification_time) { |
79 elements_.push_back(Element()); | 79 elements_.push_back(Element()); |
80 elements_.back().SetToFilePathRange(file_path, offset, length, | 80 elements_.back().SetToFilePathRange(file_path, offset, length, |
81 expected_modification_time); | 81 expected_modification_time); |
82 } | 82 } |
83 | 83 |
84 void ResourceRequestBody::AppendBlob(const GURL& blob_url) { | 84 void ResourceRequestBody::AppendBlob(const std::string& uuid) { |
85 elements_.push_back(Element()); | 85 elements_.push_back(Element()); |
86 elements_.back().SetToBlobUrl(blob_url); | 86 elements_.back().SetToBlob(uuid); |
87 } | 87 } |
88 | 88 |
89 void ResourceRequestBody::AppendFileSystemFileRange( | 89 void ResourceRequestBody::AppendFileSystemFileRange( |
90 const GURL& url, uint64 offset, uint64 length, | 90 const GURL& url, uint64 offset, uint64 length, |
91 const base::Time& expected_modification_time) { | 91 const base::Time& expected_modification_time) { |
92 elements_.push_back(Element()); | 92 elements_.push_back(Element()); |
93 elements_.back().SetToFileSystemUrlRange(url, offset, length, | 93 elements_.back().SetToFileSystemUrlRange(url, offset, length, |
94 expected_modification_time); | 94 expected_modification_time); |
95 } | 95 } |
96 | 96 |
97 net::UploadDataStream* | 97 net::UploadDataStream* |
98 ResourceRequestBody::ResolveElementsAndCreateUploadDataStream( | 98 ResourceRequestBody::ResolveElementsAndCreateUploadDataStream( |
99 BlobStorageController* blob_controller, | 99 BlobStorageContext* blob_context, |
100 fileapi::FileSystemContext* file_system_context, | 100 fileapi::FileSystemContext* file_system_context, |
101 base::TaskRunner* file_task_runner) { | 101 base::TaskRunner* file_task_runner) { |
102 // Resolve all blob elements. | 102 // Resolve all blob elements. |
103 std::vector<const Element*> resolved_elements; | 103 std::vector<const Element*> resolved_elements; |
104 for (size_t i = 0; i < elements_.size(); ++i) { | 104 for (size_t i = 0; i < elements_.size(); ++i) { |
105 const Element& element = elements_[i]; | 105 const Element& element = elements_[i]; |
106 if (element.type() == Element::TYPE_BLOB) { | 106 if (element.type() == Element::TYPE_BLOB) { |
107 ResolveBlobReference(blob_controller, element.url(), &resolved_elements); | 107 ResolveBlobReference(blob_context, element.blob_uuid(), |
| 108 &resolved_elements); |
108 } else { | 109 } else { |
109 // No need to resolve, just append the element. | 110 // No need to resolve, just append the element. |
110 resolved_elements.push_back(&element); | 111 resolved_elements.push_back(&element); |
111 } | 112 } |
112 } | 113 } |
113 | 114 |
114 ScopedVector<net::UploadElementReader> element_readers; | 115 ScopedVector<net::UploadElementReader> element_readers; |
115 for (size_t i = 0; i < resolved_elements.size(); ++i) { | 116 for (size_t i = 0; i < resolved_elements.size(); ++i) { |
116 const Element& element = *resolved_elements[i]; | 117 const Element& element = *resolved_elements[i]; |
117 switch (element.type()) { | 118 switch (element.type()) { |
118 case Element::TYPE_BYTES: | 119 case Element::TYPE_BYTES: |
119 element_readers.push_back(new BytesElementReader(this, element)); | 120 element_readers.push_back(new BytesElementReader(this, element)); |
120 break; | 121 break; |
121 case Element::TYPE_FILE: | 122 case Element::TYPE_FILE: |
122 element_readers.push_back( | 123 element_readers.push_back( |
123 new FileElementReader(this, file_task_runner, element)); | 124 new FileElementReader(this, file_task_runner, element)); |
124 break; | 125 break; |
125 case Element::TYPE_FILE_FILESYSTEM: | 126 case Element::TYPE_FILE_FILESYSTEM: |
126 element_readers.push_back( | 127 element_readers.push_back( |
127 new fileapi::UploadFileSystemFileElementReader( | 128 new fileapi::UploadFileSystemFileElementReader( |
128 file_system_context, | 129 file_system_context, |
129 element.url(), | 130 element.filesystem_url(), |
130 element.offset(), | 131 element.offset(), |
131 element.length(), | 132 element.length(), |
132 element.expected_modification_time())); | 133 element.expected_modification_time())); |
133 break; | 134 break; |
134 case Element::TYPE_BLOB: | 135 case Element::TYPE_BLOB: |
135 // Blob elements should be resolved beforehand. | 136 // Blob elements should be resolved beforehand. |
136 NOTREACHED(); | 137 NOTREACHED(); |
137 break; | 138 break; |
138 case Element::TYPE_UNKNOWN: | 139 case Element::TYPE_UNKNOWN: |
139 NOTREACHED(); | 140 NOTREACHED(); |
140 break; | 141 break; |
141 } | 142 } |
142 } | 143 } |
143 return new net::UploadDataStream(&element_readers, identifier_); | 144 return new net::UploadDataStream(&element_readers, identifier_); |
144 } | 145 } |
145 | 146 |
146 ResourceRequestBody::~ResourceRequestBody() {} | 147 ResourceRequestBody::~ResourceRequestBody() {} |
147 | 148 |
148 void ResourceRequestBody::ResolveBlobReference( | 149 void ResourceRequestBody::ResolveBlobReference( |
149 webkit_blob::BlobStorageController* blob_controller, | 150 webkit_blob::BlobStorageContext* blob_context, |
150 const GURL& blob_url, | 151 const std::string& uuid, |
151 std::vector<const Element*>* resolved_elements) { | 152 std::vector<const Element*>* resolved_elements) { |
152 DCHECK(blob_controller); | 153 DCHECK(blob_context); |
153 BlobData* blob_data = blob_controller->GetBlobDataFromUrl(blob_url); | 154 scoped_ptr<webkit_blob::BlobDataHandle> handle = |
154 DCHECK(blob_data); | 155 blob_context->GetBlobDataFromUUID(uuid); |
155 if (!blob_data) | 156 DCHECK(handle); |
| 157 if (!handle) |
156 return; | 158 return; |
157 | 159 |
158 // If there is no element in the referred blob data, just return. | 160 // If there is no element in the referred blob data, just return. |
159 if (blob_data->items().empty()) | 161 if (handle->data()->items().empty()) |
160 return; | 162 return; |
161 | 163 |
| 164 // Append the elements in the referred blob data. |
| 165 for (size_t i = 0; i < handle->data()->items().size(); ++i) { |
| 166 const BlobData::Item& item = handle->data()->items().at(i); |
| 167 DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type()); |
| 168 resolved_elements->push_back(&item); |
| 169 } |
| 170 |
162 // Ensure the blob and any attached shareable files survive until | 171 // Ensure the blob and any attached shareable files survive until |
163 // upload completion. | 172 // upload completion. |
164 SetUserData(blob_data, new base::UserDataAdapter<BlobData>(blob_data)); | 173 SetUserData(handle.get(), handle.release()); |
165 | |
166 // Append the elements in the referred blob data. | |
167 for (size_t i = 0; i < blob_data->items().size(); ++i) { | |
168 const BlobData::Item& item = blob_data->items().at(i); | |
169 DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type()); | |
170 resolved_elements->push_back(&item); | |
171 } | |
172 } | 174 } |
173 | 175 |
174 } // namespace webkit_glue | 176 } // namespace webkit_glue |
OLD | NEW |