OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/child/blob_storage/blob_transport_temporary_holder.h" |
| 6 |
| 7 #include <utility> |
| 8 |
| 9 #include "base/containers/scoped_ptr_hash_map.h" |
| 10 #include "base/stl_util.h" |
| 11 #include "content/child/blob_storage/blob_consolidation.h" |
| 12 #include "content/common/blob_storage/blob_storage_messages.h" |
| 13 #include "storage/common/blob_storage/blob_item_bytes_request.h" |
| 14 #include "storage/common/blob_storage/blob_item_bytes_response.h" |
| 15 #include "storage/common/data_element.h" |
| 16 |
| 17 using base::SharedMemory; |
| 18 using base::SharedMemoryHandle; |
| 19 using storage::BlobItemBytesRequest; |
| 20 using storage::BlobItemBytesResponse; |
| 21 using storage::IPCBlobItemRequestStrategy; |
| 22 using storage::DataElement; |
| 23 |
| 24 namespace content { |
| 25 |
| 26 using ConsolidatedItem = BlobConsolidation::ConsolidatedItem; |
| 27 using ReadStatus = BlobConsolidation::ReadStatus; |
| 28 using ResponsesStatus = BlobTransportTemporaryHolder::ResponsesStatus; |
| 29 |
| 30 BlobTransportTemporaryHolder::BlobTransportTemporaryHolder() {} |
| 31 |
| 32 BlobTransportTemporaryHolder::~BlobTransportTemporaryHolder() { |
| 33 STLDeleteValues(&blob_storage_); |
| 34 } |
| 35 |
| 36 bool BlobTransportTemporaryHolder::HoldBlobConsolidation( |
| 37 const std::string& uuid, |
| 38 scoped_ptr<BlobConsolidation> consolidation) { |
| 39 if (blob_storage_.find(uuid) != blob_storage_.end()) { |
| 40 return false; |
| 41 } |
| 42 blob_storage_.insert(std::make_pair(uuid, consolidation.release())); |
| 43 return true; |
| 44 } |
| 45 |
| 46 bool BlobTransportTemporaryHolder::GetDescriptions( |
| 47 const std::string& uuid, |
| 48 size_t max_data_population, |
| 49 std::vector<storage::DataElement>* out) { |
| 50 DCHECK(out->empty()); |
| 51 BlobConsolidation* consolidation = GetConsolidation(uuid); |
| 52 if (!consolidation) { |
| 53 return false; |
| 54 } |
| 55 const auto& consolidated_items = consolidation->consolidated_items(); |
| 56 |
| 57 size_t current_memory_population = 0; |
| 58 size_t current_item = 0; |
| 59 out->reserve(consolidated_items.size()); |
| 60 for (const ConsolidatedItem& item : consolidated_items) { |
| 61 out->push_back(DataElement()); |
| 62 auto& element = out->back(); |
| 63 |
| 64 switch (item.type) { |
| 65 case DataElement::TYPE_BYTES: { |
| 66 size_t bytes_length = static_cast<size_t>(item.length); |
| 67 if (current_memory_population + bytes_length <= max_data_population) { |
| 68 element.SetToAllocatedBytes(bytes_length); |
| 69 consolidation->ReadMemory(current_item, 0, bytes_length, |
| 70 element.mutable_bytes()); |
| 71 current_memory_population += bytes_length; |
| 72 } else { |
| 73 element.SetToBytesDescription(bytes_length); |
| 74 } |
| 75 break; |
| 76 } |
| 77 case DataElement::TYPE_FILE: { |
| 78 element.SetToFilePathRange( |
| 79 item.path, item.offset, item.length, |
| 80 base::Time::FromDoubleT(item.expected_modification_time)); |
| 81 break; |
| 82 } |
| 83 case DataElement::TYPE_BLOB: { |
| 84 element.SetToBlobRange(item.blob_uuid, item.offset, item.length); |
| 85 break; |
| 86 } |
| 87 case DataElement::TYPE_FILE_FILESYSTEM: { |
| 88 element.SetToFileSystemUrlRange( |
| 89 item.filesystem_url, item.offset, item.length, |
| 90 base::Time::FromDoubleT(item.expected_modification_time)); |
| 91 break; |
| 92 } |
| 93 case DataElement::TYPE_DISK_CACHE_ENTRY: |
| 94 case DataElement::TYPE_BYTES_DESCRIPTION: |
| 95 case DataElement::TYPE_UNKNOWN: |
| 96 NOTREACHED(); |
| 97 } |
| 98 ++current_item; |
| 99 } |
| 100 return true; |
| 101 } |
| 102 |
| 103 ResponsesStatus BlobTransportTemporaryHolder::GetResponses( |
| 104 const std::string& uuid, |
| 105 const std::vector<BlobItemBytesRequest>& requests, |
| 106 std::vector<SharedMemoryHandle>* memory_handles, |
| 107 const std::vector<IPC::PlatformFileForTransit>& file_handles, |
| 108 std::vector<BlobItemBytesResponse>* out) { |
| 109 DCHECK(out->empty()); |
| 110 BlobConsolidation* consolidation = GetConsolidation(uuid); |
| 111 if (!consolidation) |
| 112 return ResponsesStatus::BLOB_NOT_FOUND; |
| 113 const auto& consolidated_items = consolidation->consolidated_items(); |
| 114 |
| 115 base::ScopedPtrHashMap<size_t, scoped_ptr<SharedMemory>> opened_memory; |
| 116 for (const BlobItemBytesRequest& request : requests) { |
| 117 if (request.renderer_item_index >= consolidated_items.size()) |
| 118 return ResponsesStatus::INVALID_ITEM_INDEX; |
| 119 |
| 120 const ConsolidatedItem& item = |
| 121 consolidated_items[request.renderer_item_index]; |
| 122 if (request.renderer_item_offset + request.size > item.length) |
| 123 return ResponsesStatus::INVALID_DATA_RANGE; |
| 124 if (item.type != DataElement::TYPE_BYTES) |
| 125 return ResponsesStatus::INVALID_ITEM; |
| 126 |
| 127 out->push_back(BlobItemBytesResponse(request.request_number)); |
| 128 switch (request.transport_strategy) { |
| 129 case IPCBlobItemRequestStrategy::IPC: { |
| 130 BlobItemBytesResponse& response = out->back(); |
| 131 ReadStatus status = consolidation->ReadMemory( |
| 132 request.renderer_item_index, request.renderer_item_offset, |
| 133 request.size, response.allocate_mutable_data(request.size)); |
| 134 CHECK(status == ReadStatus::OK) |
| 135 << "Error reading from consolidated blob: " |
| 136 << static_cast<int>(status); |
| 137 break; |
| 138 } |
| 139 case IPCBlobItemRequestStrategy::SHARED_MEMORY: { |
| 140 if (request.handle_index >= memory_handles->size()) { |
| 141 DCHECK_LT(request.handle_index, memory_handles->size()); |
| 142 return ResponsesStatus::INVALID_HANDLE_INDEX; |
| 143 } |
| 144 SharedMemory* memory = nullptr; |
| 145 auto memory_it = opened_memory.find(request.handle_index); |
| 146 if (memory_it == opened_memory.end()) { |
| 147 SharedMemoryHandle& handle = (*memory_handles)[request.handle_index]; |
| 148 DCHECK(SharedMemory::IsHandleValid(handle)); |
| 149 scoped_ptr<SharedMemory> shared_memory( |
| 150 new SharedMemory(handle, false)); |
| 151 if (!shared_memory->Map(request.size)) { |
| 152 return ResponsesStatus::SHARED_MEMORY_MAP_FAILED; |
| 153 } |
| 154 memory = shared_memory.get(); |
| 155 opened_memory.add(request.handle_index, shared_memory.Pass()); |
| 156 } else { |
| 157 memory = memory_it->second; |
| 158 } |
| 159 CHECK(memory->memory()) << "Couldn't map memory for blob transfer."; |
| 160 ReadStatus status = consolidation->ReadMemory( |
| 161 request.renderer_item_index, request.renderer_item_offset, |
| 162 request.size, |
| 163 static_cast<char*>(memory->memory()) + request.handle_offset); |
| 164 CHECK(status == ReadStatus::OK) |
| 165 << "Error reading from consolidated blob: " |
| 166 << static_cast<int>(status); |
| 167 break; |
| 168 } |
| 169 case IPCBlobItemRequestStrategy::FILE: |
| 170 NOTREACHED() << "TODO(dmurph): Not implemented."; |
| 171 break; |
| 172 case IPCBlobItemRequestStrategy::UNKNOWN: |
| 173 NOTREACHED(); |
| 174 break; |
| 175 } |
| 176 } |
| 177 return ResponsesStatus::SUCCESS; |
| 178 } |
| 179 |
| 180 void BlobTransportTemporaryHolder::ReleaseBlob(const std::string& uuid) { |
| 181 auto iter = blob_storage_.find(uuid); |
| 182 if (iter != blob_storage_.end()) { |
| 183 BlobConsolidation* consolidation = iter->second; |
| 184 delete consolidation; |
| 185 blob_storage_.erase(iter); |
| 186 } |
| 187 } |
| 188 |
| 189 BlobConsolidation* BlobTransportTemporaryHolder::GetConsolidation( |
| 190 const std::string& uuid) { |
| 191 auto iter = blob_storage_.find(uuid); |
| 192 if (iter == blob_storage_.end()) { |
| 193 return nullptr; |
| 194 } else { |
| 195 return iter->second; |
| 196 } |
| 197 } |
| 198 |
| 199 } // namespace content |
OLD | NEW |