OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "content/browser/loader/upload_data_stream_builder.h" | 5 #include "content/browser/loader/upload_data_stream_builder.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "content/browser/fileapi/upload_file_system_file_element_reader.h" | 8 #include "content/browser/fileapi/upload_file_system_file_element_reader.h" |
9 #include "content/common/resource_request_body.h" | 9 #include "content/common/resource_request_body.h" |
10 #include "net/base/elements_upload_data_stream.h" | 10 #include "net/base/elements_upload_data_stream.h" |
11 #include "net/base/upload_bytes_element_reader.h" | 11 #include "net/base/upload_bytes_element_reader.h" |
12 #include "net/base/upload_file_element_reader.h" | 12 #include "net/base/upload_file_element_reader.h" |
13 #include "storage/browser/blob/blob_data_handle.h" | 13 #include "storage/browser/blob/blob_data_handle.h" |
| 14 #include "storage/browser/blob/blob_data_snapshot.h" |
14 #include "storage/browser/blob/blob_storage_context.h" | 15 #include "storage/browser/blob/blob_storage_context.h" |
15 | 16 |
16 using storage::BlobData; | |
17 using storage::BlobDataHandle; | |
18 using storage::BlobStorageContext; | |
19 | |
20 namespace content { | 17 namespace content { |
21 namespace { | 18 namespace { |
22 | 19 |
23 // A subclass of net::UploadBytesElementReader which owns ResourceRequestBody. | 20 // A subclass of net::UploadBytesElementReader which owns ResourceRequestBody. |
24 class BytesElementReader : public net::UploadBytesElementReader { | 21 class BytesElementReader : public net::UploadBytesElementReader { |
25 public: | 22 public: |
26 BytesElementReader(ResourceRequestBody* resource_request_body, | 23 BytesElementReader(ResourceRequestBody* resource_request_body, |
27 const ResourceRequestBody::Element& element) | 24 const ResourceRequestBody::Element& element) |
28 : net::UploadBytesElementReader(element.bytes(), element.length()), | 25 : net::UploadBytesElementReader(element.bytes(), element.length()), |
29 resource_request_body_(resource_request_body) { | 26 resource_request_body_(resource_request_body) { |
(...skipping 27 matching lines...) Expand all Loading... |
57 | 54 |
58 ~FileElementReader() override {} | 55 ~FileElementReader() override {} |
59 | 56 |
60 private: | 57 private: |
61 scoped_refptr<ResourceRequestBody> resource_request_body_; | 58 scoped_refptr<ResourceRequestBody> resource_request_body_; |
62 | 59 |
63 DISALLOW_COPY_AND_ASSIGN(FileElementReader); | 60 DISALLOW_COPY_AND_ASSIGN(FileElementReader); |
64 }; | 61 }; |
65 | 62 |
66 void ResolveBlobReference( | 63 void ResolveBlobReference( |
| 64 ResourceRequestBody* body, |
67 storage::BlobStorageContext* blob_context, | 65 storage::BlobStorageContext* blob_context, |
68 const ResourceRequestBody::Element& element, | 66 const ResourceRequestBody::Element& element, |
69 std::vector<const ResourceRequestBody::Element*>* resolved_elements) { | 67 std::vector<const ResourceRequestBody::Element*>* resolved_elements) { |
70 DCHECK(blob_context); | 68 DCHECK(blob_context); |
71 scoped_ptr<storage::BlobDataHandle> handle = | 69 scoped_ptr<storage::BlobDataHandle> handle = |
72 blob_context->GetBlobDataFromUUID(element.blob_uuid()); | 70 blob_context->GetBlobDataFromUUID(element.blob_uuid()); |
73 DCHECK(handle); | 71 DCHECK(handle); |
74 if (!handle) | 72 if (!handle) |
75 return; | 73 return; |
76 | 74 |
| 75 // TODO(dmurph): Create a reader for blobs instead of decomposing the blob |
| 76 // and storing the snapshot on the request to keep the resources around. |
| 77 // Currently a handle is attached to the request in the resource dispatcher |
| 78 // host, so we know the blob won't go away, but it's not very clear or useful. |
| 79 scoped_ptr<storage::BlobDataSnapshot> snapshot = handle->CreateSnapshot(); |
77 // If there is no element in the referred blob data, just return. | 80 // If there is no element in the referred blob data, just return. |
78 if (handle->data()->items().empty()) | 81 if (snapshot->items().empty()) |
79 return; | 82 return; |
80 | 83 |
81 // Append the elements in the referenced blob data. | 84 // Append the elements in the referenced blob data. |
82 for (size_t i = 0; i < handle->data()->items().size(); ++i) { | 85 for (const auto& item : snapshot->items()) { |
83 const BlobData::Item& item = handle->data()->items().at(i); | 86 DCHECK_NE(storage::DataElement::TYPE_BLOB, item->type()); |
84 DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type()); | 87 resolved_elements->push_back(item->data_element_ptr()); |
85 resolved_elements->push_back(&item); | |
86 } | 88 } |
| 89 const void* key = snapshot.get(); |
| 90 body->SetUserData(key, snapshot.release()); |
87 } | 91 } |
88 | 92 |
89 } // namespace | 93 } // namespace |
90 | 94 |
91 scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build( | 95 scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build( |
92 ResourceRequestBody* body, | 96 ResourceRequestBody* body, |
93 BlobStorageContext* blob_context, | 97 storage::BlobStorageContext* blob_context, |
94 storage::FileSystemContext* file_system_context, | 98 storage::FileSystemContext* file_system_context, |
95 base::TaskRunner* file_task_runner) { | 99 base::TaskRunner* file_task_runner) { |
96 // Resolve all blob elements. | 100 // Resolve all blob elements. |
97 std::vector<const ResourceRequestBody::Element*> resolved_elements; | 101 std::vector<const ResourceRequestBody::Element*> resolved_elements; |
98 for (size_t i = 0; i < body->elements()->size(); ++i) { | 102 for (size_t i = 0; i < body->elements()->size(); ++i) { |
99 const ResourceRequestBody::Element& element = (*body->elements())[i]; | 103 const ResourceRequestBody::Element& element = (*body->elements())[i]; |
100 if (element.type() == ResourceRequestBody::Element::TYPE_BLOB) | 104 if (element.type() == ResourceRequestBody::Element::TYPE_BLOB) |
101 ResolveBlobReference(blob_context, element, &resolved_elements); | 105 ResolveBlobReference(body, blob_context, element, &resolved_elements); |
102 else | 106 else |
103 resolved_elements.push_back(&element); | 107 resolved_elements.push_back(&element); |
104 } | 108 } |
105 | 109 |
106 ScopedVector<net::UploadElementReader> element_readers; | 110 ScopedVector<net::UploadElementReader> element_readers; |
107 for (size_t i = 0; i < resolved_elements.size(); ++i) { | 111 for (size_t i = 0; i < resolved_elements.size(); ++i) { |
108 const ResourceRequestBody::Element& element = *resolved_elements[i]; | 112 const ResourceRequestBody::Element& element = *resolved_elements[i]; |
109 switch (element.type()) { | 113 switch (element.type()) { |
110 case ResourceRequestBody::Element::TYPE_BYTES: | 114 case ResourceRequestBody::Element::TYPE_BYTES: |
111 element_readers.push_back(new BytesElementReader(body, element)); | 115 element_readers.push_back(new BytesElementReader(body, element)); |
112 break; | 116 break; |
113 case ResourceRequestBody::Element::TYPE_FILE: | 117 case ResourceRequestBody::Element::TYPE_FILE: |
114 element_readers.push_back( | 118 element_readers.push_back( |
115 new FileElementReader(body, file_task_runner, element)); | 119 new FileElementReader(body, file_task_runner, element)); |
116 break; | 120 break; |
117 case ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM: | 121 case ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM: |
118 // If |body| contains any filesystem URLs, the caller should have | 122 // If |body| contains any filesystem URLs, the caller should have |
119 // supplied a FileSystemContext. | 123 // supplied a FileSystemContext. |
120 DCHECK(file_system_context); | 124 DCHECK(file_system_context); |
121 element_readers.push_back( | 125 element_readers.push_back( |
122 new content::UploadFileSystemFileElementReader( | 126 new content::UploadFileSystemFileElementReader( |
123 file_system_context, | 127 file_system_context, |
124 element.filesystem_url(), | 128 element.filesystem_url(), |
125 element.offset(), | 129 element.offset(), |
126 element.length(), | 130 element.length(), |
127 element.expected_modification_time())); | 131 element.expected_modification_time())); |
128 break; | 132 break; |
129 case ResourceRequestBody::Element::TYPE_BLOB: | 133 case ResourceRequestBody::Element::TYPE_BLOB: |
130 // Blob elements should be resolved beforehand. | 134 // Blob elements should be resolved beforehand. |
| 135 // TODO(dmurph): Create blob reader and store the snapshot in there. |
131 NOTREACHED(); | 136 NOTREACHED(); |
132 break; | 137 break; |
133 case ResourceRequestBody::Element::TYPE_UNKNOWN: | 138 case ResourceRequestBody::Element::TYPE_UNKNOWN: |
134 NOTREACHED(); | 139 NOTREACHED(); |
135 break; | 140 break; |
136 } | 141 } |
137 } | 142 } |
138 | 143 |
139 return make_scoped_ptr( | 144 return make_scoped_ptr( |
140 new net::ElementsUploadDataStream(element_readers.Pass(), | 145 new net::ElementsUploadDataStream(element_readers.Pass(), |
141 body->identifier())); | 146 body->identifier())); |
142 } | 147 } |
143 | 148 |
144 } // namespace content | 149 } // namespace content |
OLD | NEW |