WIP POC blob transport over mojo

third_party/WebKit/Source/platform/blob/BlobData.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/blob/BlobData.h"
 
 #include <memory>
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/UUID.h"
+#include "platform/WebTaskRunner.h"
+#include "platform/blob/BlobBytesProvider.h"
 #include "platform/blob/BlobRegistry.h"
 #include "platform/text/LineEnding.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
+#include "platform/wtf/Time.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/TextEncoding.h"
+#include "public/platform/InterfaceProvider.h"
+#include "public/platform/Platform.h"
 
 namespace blink {
 
 namespace {
 
 // All consecutive items that are accumulate to < this number will have the
 // data appended to the same item.
 static const size_t kMaxConsolidatedItemSizeInBytes = 15 * 1024;
 
 // http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob
 bool IsValidBlobType(const String& type) {
   for (unsigned i = 0; i < type.length(); ++i) {
     UChar c = type[i];
     if (c < 0x20 || c > 0x7E)
       return false;
   }
   return true;
 }
 
+Time TimeFromDouble(double dt) {
+  if (dt == 0 || std::isnan(dt))
+    return Time();
+  return Time::FromSeconds(base::Time::kTimeTToMicrosecondsOffset / 1000000 +
+                           dt);
+}
+
+void BindBytesProvider(std::unique_ptr<BlobBytesProvider> provider,
+                       storage::mojom::blink::BytesProviderRequest request) {
+  mojo::MakeStrongBinding(std::move(provider), std::move(request));
+}
+
 }  // namespace
 
 const long long BlobDataItem::kToEndOfFile = -1;
 
 RawData::RawData() {}
 
 void RawData::DetachFromCurrentThread() {}
 
 void BlobDataItem::DetachFromCurrentThread() {
   data->DetachFromCurrentThread();
@@ skipping 163 matching lines @@
     return false;
   if (last_item.data->length() + length > kMaxConsolidatedItemSizeInBytes)
     return false;
   return true;
 }
 
 BlobDataHandle::BlobDataHandle()
     : uuid_(CreateCanonicalUUIDString()),
       size_(0),
       is_single_unknown_size_file_(false) {
-  BlobRegistry::RegisterBlobData(uuid_, BlobData::Create());
+  // BlobRegistry::RegisterBlobData(uuid_, BlobData::Create());
+
+  storage::mojom::blink::BlobRegistryPtr registry;
+  Platform::Current()->GetInterfaceProvider()->GetInterface(
+      MakeRequest(&registry));
+  registry->Register(MakeRequest(&blob_), uuid_, "", "", {});
 }
 
 BlobDataHandle::BlobDataHandle(std::unique_ptr<BlobData> data, long long size)
     : uuid_(CreateCanonicalUUIDString()),
       type_(data->ContentType().IsolatedCopy()),
       size_(size),
       is_single_unknown_size_file_(data->IsSingleUnknownSizeFile()) {
-  BlobRegistry::RegisterBlobData(uuid_, std::move(data));
+  storage::mojom::blink::BlobRegistryPtr registry;
+  // TODO(mek): Getting interface relies on main thread to make progress, even
+  // in workers.
+  Platform::Current()->GetInterfaceProvider()->GetInterface(
+      MakeRequest(&registry));
+
+  base::SingleThreadTaskRunner* io_runner = BlobRegistry::GetIORunner();
+  // TODO(mek): Get max data population from somewhere.
+  size_t max_data_population = 5;  // 250 * 1024;
+  Vector<storage::mojom::blink::DataElementPtr> elements;
+  size_t current_memory_population = 0;
+  BlobBytesProvider* last_bytes_provider = nullptr;
+  storage::mojom::blink::DataElementPtr nullElement = nullptr;
+  for (const auto& item : data->Items()) {
+    switch (item.type) {
+      case BlobDataItem::kData:
+        if (item.data->length() != 0) {
+          const storage::mojom::blink::DataElementPtr& lastElement =
+              elements.IsEmpty() ? nullElement : elements.back();
+          if (current_memory_population + item.data->length() <=
+              max_data_population) {
+            if (lastElement && lastElement->is_bytes()) {
+              lastElement->get_bytes().Append(item.data->data(),
+                                              item.data->length());
+            } else {
+              Vector<uint8_t> bytes;
+              bytes.Append(item.data->data(), item.data->length());
+              elements.push_back(
+                  storage::mojom::blink::DataElement::NewBytes(bytes));
+            }
+          } else {
+            if (lastElement && lastElement->is_large_bytes() &&
+                last_bytes_provider) {
+              lastElement->get_large_bytes()->length += item.data->length();
+              last_bytes_provider->AppendData(item.data);
+            } else {
+              storage::mojom::blink::BytesProviderPtr ptr;
+              if (io_runner) {
+                auto provider = WTF::MakeUnique<BlobBytesProvider>(item.data);
+                last_bytes_provider = provider.get();
+                io_runner->PostTask(
+                    FROM_HERE,
+                    base::Bind(&BindBytesProvider,
+                               base::Passed(std::move(provider)),
+                               base::Passed(mojo::MakeRequest(&ptr))));
+                last_bytes_provider->uuid = uuid_.IsolatedCopy();
+              } else
+                mojo::MakeRequest(&ptr);
+              elements.push_back(
+                  storage::mojom::blink::DataElement::NewLargeBytes(
+                      storage::mojom::blink::DataElementBytes::New(
+                          item.data->length(), std::move(ptr))));
+            }
+          }
+        }
+        break;
+      case BlobDataItem::kFile:
+        if (item.length != 0)
+          elements.push_back(storage::mojom::blink::DataElement::NewFile(
+              storage::mojom::blink::DataElementFile::New(
+                  item.path.IsNull() ? "" : item.path, item.offset, item.length,
+                  TimeFromDouble(item.expected_modification_time))));
+        break;
+      case BlobDataItem::kBlob:
+        if (item.length != 0) {
+          storage::mojom::blink::BlobPtr blob;
+          item.blob_data_handle->blob_->Clone(MakeRequest(&blob));
+          elements.push_back(storage::mojom::blink::DataElement::NewBlob(
+              storage::mojom::blink::DataElementBlob::New(
+                  std::move(blob), item.offset, item.length)));
+        }
+        break;
+      case BlobDataItem::kFileSystemURL:
+        if (item.length != 0)
+          elements.push_back(
+              storage::mojom::blink::DataElement::NewFileFilesystem(
+                  storage::mojom::blink::DataElementFilesystemURL::New(
+                      item.file_system_url, item.offset, item.length,
+                      TimeFromDouble(item.expected_modification_time))));
+        break;
+    }
+  }
+  registry->Register(MakeRequest(&blob_), uuid_, type_.IsNull() ? "" : type_,
+                     "", std::move(elements));
+  // BlobRegistry::RegisterBlobData(uuid_, std::move(data));
 }
 
 BlobDataHandle::BlobDataHandle(const String& uuid,
                                const String& type,
                                long long size)
     : uuid_(uuid.IsolatedCopy()),
       type_(IsValidBlobType(type) ? type.IsolatedCopy() : ""),
       size_(size),
       is_single_unknown_size_file_(false) {
-  BlobRegistry::AddBlobDataRef(uuid_);
+  // BlobRegistry::AddBlobDataRef(uuid_);
+
+  storage::mojom::blink::BlobRegistryPtr registry;
+  Platform::Current()->GetInterfaceProvider()->GetInterface(
+      MakeRequest(&registry));
+  registry->DeprecatedGetBlob(uuid_, MakeRequest(&blob_));
 }
 
 BlobDataHandle::~BlobDataHandle() {
-  BlobRegistry::RemoveBlobDataRef(uuid_);
+  //  BlobRegistry::RemoveBlobDataRef(uuid_);
 }
 
 }  // namespace blink