Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(794)

Unified Diff: storage/browser/blob/blob_transport_strategy.h

Issue 1098853003: [BlobAsync] Patch 4: Browser Classes & Logic. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix for template ambiguity Created 5 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: storage/browser/blob/blob_transport_strategy.h
diff --git a/storage/browser/blob/blob_transport_strategy.h b/storage/browser/blob/blob_transport_strategy.h
new file mode 100644
index 0000000000000000000000000000000000000000..82044eb9eae4c90e67b6de9e3992ae41895f0b91
--- /dev/null
+++ b/storage/browser/blob/blob_transport_strategy.h
@@ -0,0 +1,128 @@
+// Copyright 2015 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.
+
+#ifndef STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_STRATEGY_H_
+#define STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_STRATEGY_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "storage/browser/storage_browser_export.h"
+#include "storage/common/data_element.h"
+#include "storage/common/fileapi/blob_item_bytes_request.h"
+
+namespace storage {
+
+// This class determines and stores the strategy for asynchronously transporting
+// memory from the renderer to the browser. This involves two transformations:
+// 1. Transforming the data storage to be efficient in-transport. This can
+// mean that data is consolidated from cross-blob or cross-file boundaries
+// in the blob in a common block of shared memory or a file.
+// 2. Transforming the transport data into the browser storage representation.
+// This can simply mirror the renderer representation, or it can be instead
+// pointing to transport representation with offsets and sizes.
+//
+// The initial implementation of this is simple, but the protocol allows any
+// sort of flexibility, as everything has an offset and size specified.
+class STORAGE_EXPORT BlobTransportStrategy {
+ public:
+ enum Mode { MODE_UNKNOWN = 0, MODE_NO_DISK, MODE_DISK };
+
+ enum Error {
+ ERROR_NONE = 0,
+ ERROR_TOO_LARGE, // This item can't fit in disk or memory
+ ERROR_INVALID_PARAMS
+ };
+
+ struct MemoryItemRequest {
+ size_t browser_item_index;
+ size_t browser_item_offset;
+ BlobItemBytesRequest message;
+ };
+
+ BlobTransportStrategy();
+ virtual ~BlobTransportStrategy();
+
+ // Determines the requests, file handles, and memory handles for the given
+ // system state and blob description. Can be called multiple times to reset
+ // the object.
+ //
+ // mode: The transportation mode, either MODE_NO_DISK or MODE_DISK. NO_DISK
+ // means that we won't transport files over disk.
+ // max_ipc_memory_size: Maximum amount of memory that we can include in our
+ // IPC message.
+ // max_shared_memory_size: Maximum amount of memory we can store
+ // in a shared memory block.
+ // max_file_size: Maximum amount of memory we can store in a file.
+ // max_blob_in_memory_size: Maximum size of a blob before it skips being
+ // stored in memory and goes straight to a file.
+ // disk_space_left: The amount of disk space left.
+ // memory_left: The amount of memory left in our memory cache.
+ void Initialize(Mode mode,
+ size_t max_ipc_memory_size,
+ size_t max_shared_memory_size,
+ uint64_t max_file_size,
+ size_t max_blob_in_memory_size,
+ uint64_t disk_space_left,
+ size_t memory_left,
+ const std::vector<DataElement>& blob_item_infos);
+
+ const std::vector<uint64_t>& file_handles() const { return file_handles_; }
+
+ const std::vector<size_t>& shared_memory_handles() const {
+ return shared_memory_handles_;
+ }
+
+ const std::vector<MemoryItemRequest>& requests() const { return requests_; }
+
+ Error error() const { return error_; }
+
+ private:
+ // This iterates of the data elements and segments the 'bytes' data into
+ // the smallest number of segments given the max_segment_size.
+ // The callback describes either:
+ // * A non-memory item
+ // * A partition of a bytes element which will be populated into a given
+ // segment and segment offset.
+ // The function signature of the template functor is:
+ // void(DataElement::Type /*element_type*/,
+ // size_t /*element_index*/,
+ // SizeType /*element_offset*/,
+ // size_t /*segment_index*/,
+ // SizeType /*segment_offset*/,
+ // SizeType /*size*/)
+ //
+ // element: A DataElement from the |items| vector. The callback is called
+ // for every single element in the vector (multiple times
+ // if the element needs to be split up)
+ // segment: A memory segment, with a maximum size of |max_segment_size|.
+ //
+ // Assumptions: All memory items are consolidated. As in, there are no two
+ // 'bytes' items next to eachother.
+ template <typename ForEachFunctor, typename SizeType>
+ static void ForEachWithSegment(const std::vector<DataElement>& items,
+ SizeType max_segment_size,
+ ForEachFunctor function);
+
+ // This populates the |segment_sizes| vector with the sizes of the segments
+ // that will be used in the transport strategy.
+ template <typename SizeType>
+ static void CreateHandleSizes(SizeType total_memory_size,
+ SizeType max_segment_size,
+ std::vector<SizeType>* segment_sizes);
+
+ Error error_;
+
+ std::vector<uint64_t> file_handles_;
+ std::vector<size_t> shared_memory_handles_;
+
+ std::vector<MemoryItemRequest> requests_;
+
+ DISALLOW_COPY_AND_ASSIGN(BlobTransportStrategy);
+};
+
+} // namespace storage
+
+#endif // STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_STRATEGY_H_
+

Powered by Google App Engine
This is Rietveld 408576698