Support for parsing external file references in a glTF resource.

chrome/browser/android/vr_shell/gltf_parser.cc

 // Copyright 2017 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.
 
 #include "chrome/browser/android/vr_shell/gltf_parser.h"
 
 #include "base/base64.h"
+#include "base/files/file_util.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "net/base/data_url.h"
+#include "url/gurl.h"
 
 namespace vr_shell {
 
-constexpr char kBase64Header[] = "data:application/octet-stream;base64,";
-constexpr size_t kBase64HeaderSize = 37;
-
 GltfParser::GltfParser() {}
 
 GltfParser::~GltfParser() = default;
 
 std::unique_ptr<gltf::Asset> GltfParser::Parse(
     const base::DictionaryValue& dict) {
-  std::string gltf_version;
-  if (!dict.GetString("asset.version", &gltf_version) || gltf_version != "1.0")
-    return nullptr;
-
   asset_ = base::MakeUnique<gltf::Asset>();
 
   if (!ParseInternal(dict)) {
-    asset_.reset();
+    Clear();

[mthiesse, 2017/03/23 15:00:10]

You probably want to clear on the success case as well, so you're not holding
onto unnecessary memory.

[acondor_, 2017/03/23 16:28:12]

Done.

     return nullptr;
   }
 
   return std::move(asset_);
 }
 
+// Use this method if the glTF file references external files.

[mthiesse, 2017/03/23 15:00:10]

Comments should go in the header.

[mthiesse, 2017/03/23 15:00:10]

It shouldn't matter whether your input is a dictionary or a file. Users should
be able to use either interface regardless of whether or not their glTF file
references external files. The comment should state that if their glTF
references external files, or if their source is a file, that parsing should not
be run on the UI thread.

[acondor_, 2017/03/23 15:29:21]

Just to clarify, there would be no way to process a dictionary that references
other files, because their path would be relative to the glTF directory.

[acondor_, 2017/03/23 16:28:12]

Done.

+// If so, use it in the FILE BrowserThread.
+std::unique_ptr<gltf::Asset> GltfParser::Parse(const base::FilePath& path) {
+  JSONFileValueDeserializer json_deserializer(path);
+  int error_code;
+  std::string error_msg;
+  auto asset_value = json_deserializer.Deserialize(&error_code, &error_msg);
+  if (!asset_value)
+    return nullptr;
+  base::DictionaryValue* asset;
+  if (!asset_value->GetAsDictionary(&asset))
+    return nullptr;
+  path_ = path;
+  return Parse(*asset);
+}
+
 bool GltfParser::ParseInternal(const base::DictionaryValue& dict) {
+  std::string gltf_version;
+  if (!dict.GetString("asset.version", &gltf_version) || gltf_version != "1.0")
+    return false;
+
   const base::DictionaryValue* sub_dict;
   if (dict.GetDictionary("buffers", &sub_dict) && !SetBuffers(*sub_dict))
     return false;
   if (dict.GetDictionary("bufferViews", &sub_dict) &&
       !SetBufferViews(*sub_dict))
     return false;
   if (dict.GetDictionary("accessors", &sub_dict) && !SetAccessors(*sub_dict))
     return false;
   if (dict.GetDictionary("meshes", &sub_dict) && !SetMeshes(*sub_dict))
     return false;
@@ skipping 12 matching lines @@
 
   return true;
 }
 
 bool GltfParser::SetBuffers(const base::DictionaryValue& dict) {
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* buffer_dict;
     if (!it.value().GetAsDictionary(&buffer_dict))
       return false;
 
-    std::string uri;
-    // TODO(acondor): Support files. Only inline data is supported now.
-    if (!buffer_dict->GetString("uri", &uri) ||
-        uri.substr(0, kBase64HeaderSize) != kBase64Header)
+    std::string uri_str;
+    if (!buffer_dict->GetString("uri", &uri_str))
       return false;
-
-    auto buffer = base::MakeUnique<gltf::Buffer>();
-    if (!base::Base64Decode(uri.substr(kBase64HeaderSize), buffer.get()))
+    auto buffer = ProcessUri(uri_str);
+    if (!buffer)
       return false;
 
     int byte_length;
     if (buffer_dict->GetInteger("byteLength", &byte_length) &&
         static_cast<int>(buffer->length()) != byte_length)
       return false;
 
     buffer_ids_[it.key()] = asset_->AddBuffer(std::move(buffer));
   }
   return true;
 }
 
+std::unique_ptr<gltf::Buffer> GltfParser::ProcessUri(
+    const std::string& uri_str) {
+  auto uri = path_.empty() ? GURL(uri_str)
+                           : GURL("file://" + path_.value()).Resolve(uri_str);
+  if (!uri.is_valid())
+    return nullptr;
+  if (uri.SchemeIs(url::kDataScheme)) {
+    std::string mime_type;
+    std::string charset;
+    auto data = base::MakeUnique<gltf::Buffer>();
+    if (!net::DataURL::Parse(uri, &mime_type, &charset, data.get()))
+      return nullptr;
+    return data;
+  }
+  if (uri.SchemeIsFile()) {
+    auto data = base::MakeUnique<gltf::Buffer>();
+    if (!base::ReadFileToString(base::FilePath(uri.path()), data.get()))
+      return nullptr;
+    return data;
+  }
+  // No other schemes are supported yet.
+  return nullptr;
+}
+
 bool GltfParser::SetBufferViews(const base::DictionaryValue& dict) {
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* buffer_view_dict;
     if (!it.value().GetAsDictionary(&buffer_view_dict))
       return false;
 
     auto buffer_view = base::MakeUnique<gltf::BufferView>();
     std::string buffer_key;
     if (!buffer_view_dict->GetString("buffer", &buffer_key))
       return false;
@@ skipping 165 matching lines @@
           return false;
         scene->nodes.push_back(asset_->GetNode(node_it->second));
       }
     }
 
     scene_ids_[it.key()] = asset_->AddScene(std::move(scene));
   }
   return true;
 }
 
+void GltfParser::Clear() {
+  asset_.reset();
+  path_.clear();
+  buffer_ids_.clear();
+  buffer_view_ids_.clear();
+  accessor_ids_.clear();
+  node_ids_.clear();
+  mesh_ids_.clear();
+  scene_ids_.clear();
+}
+
 }  // namespace vr_shell