Implementing Binary glTF reader for the VR controller model

chrome/browser/android/vr_shell/gltf_parser_unittest.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 <memory>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/test/paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace vr_shell {
 
-class GltfParserTest : public testing::Test {
+class DataDrivenTest : public testing::Test {
  protected:
   static void SetUpTestCase() { test::RegisterPathProvider(); }
 
   void SetUp() override { PathService::Get(test::DIR_TEST_DATA, &data_dir_); }
 
   base::FilePath data_dir_;
+};
 
+class GltfParserTest : public DataDrivenTest {
+ protected:
   std::unique_ptr<base::DictionaryValue> Deserialize(
       const base::FilePath& gltf_path);
 };
 
+class BinaryGltfParserTest : public DataDrivenTest {};
+
 std::unique_ptr<base::DictionaryValue> GltfParserTest::Deserialize(
     const base::FilePath& gltf_path) {
   int error_code;
   std::string error_msg;
   JSONFileValueDeserializer json_deserializer(gltf_path);
   auto asset_value = json_deserializer.Deserialize(&error_code, &error_msg);
   EXPECT_NE(nullptr, asset_value);
   base::DictionaryValue* asset;
   EXPECT_TRUE(asset_value->GetAsDictionary(&asset));
   asset_value.release();
   return std::unique_ptr<base::DictionaryValue>(asset);
 }
 
 TEST_F(GltfParserTest, Parse) {
   auto asset = Deserialize(data_dir_.Append("sample_inline.gltf"));
   GltfParser parser;
   std::vector<std::unique_ptr<gltf::Buffer>> buffers;
 
-  auto gltf_model = parser.Parse(*asset, &buffers);
+  std::unique_ptr<gltf::Asset> gltf_model = parser.Parse(*asset, &buffers);
   EXPECT_TRUE(gltf_model);
   EXPECT_EQ(1u, buffers.size());
 
   const gltf::Buffer* buffer = buffers[0].get();
   EXPECT_EQ("HELLO WORLD!", *buffer);
   EXPECT_EQ(12u, buffer->length());
 
   const gltf::BufferView* buffer_view = gltf_model->GetBufferView(0);
   EXPECT_NE(nullptr, buffer_view);
   EXPECT_EQ(nullptr, gltf_model->GetBufferView(1));
@@ skipping 71 matching lines @@
   std::unique_ptr<base::Value> value;
   asset->Remove("buffers.dummyBuffer.uri", &value);
   EXPECT_EQ(nullptr, parser.Parse(*asset, &buffers));
 }
 
 TEST_F(GltfParserTest, ParseExternal) {
   auto gltf_path = data_dir_.Append("sample_external.gltf");
   GltfParser parser;
   std::vector<std::unique_ptr<gltf::Buffer>> buffers;
 
-  auto gltf_model = parser.Parse(gltf_path, &buffers);
+  std::unique_ptr<gltf::Asset> gltf_model = parser.Parse(gltf_path, &buffers);
   EXPECT_NE(nullptr, gltf_model);
   EXPECT_EQ(1u, buffers.size());
   const gltf::Buffer* buffer = buffers[0].get();
   EXPECT_NE(nullptr, buffer);
   EXPECT_EQ("HELLO WORLD!", *buffer);
   EXPECT_EQ(12u, buffer->length());
 }
 
 TEST_F(GltfParserTest, ParseExternalNoPath) {
   auto asset = Deserialize(data_dir_.Append("sample_external.gltf"));
   GltfParser parser;
   std::vector<std::unique_ptr<gltf::Buffer>> buffers;
 
   // Parsing fails when no path is provided.
   EXPECT_EQ(nullptr, parser.Parse(*asset, &buffers));
 }
 
+TEST_F(BinaryGltfParserTest, ParseBinary) {
+  std::string data;
+  EXPECT_TRUE(base::ReadFileToString(data_dir_.Append("sample.glb"), &data));
+  base::StringPiece glb_data(data);
+  std::vector<std::unique_ptr<gltf::Buffer>> buffers;
+  std::unique_ptr<gltf::Asset> asset =
+      BinaryGltfParser::Parse(glb_data, &buffers);
+  EXPECT_TRUE(asset);
+  EXPECT_EQ(1u, buffers.size());
+  const gltf::BufferView* buffer_view = asset->GetBufferView(0);
+  EXPECT_TRUE(buffer_view);
+  EXPECT_EQ(0, buffer_view->buffer);
+}
+
 }  // namespace vr_shell