Refactor VR math off of GVR types, onto gfx types where possible.

chrome/browser/android/vr_shell/vr_gl_util.cc

 // Copyright 2016 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/vr_gl_util.h"
 
 namespace vr_shell {
 
 // This code is adapted from the GVR Treasure Hunt demo source.
-std::array<float, 16> MatrixToGLArray(const gvr::Mat4f& matrix) {
+std::array<float, 16> MatrixToGLArray(const vr::Mat4f& matrix) {
   // Note that this performs a *transpose* to a column-major matrix array, as
   // expected by GL. The input matrix has translation components at [i][3] for
   // use with row vectors and premultiplied transforms. In the output, the
   // translation elements are at the end at positions 3*4+i.
   std::array<float, 16> result;
   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j) {
-      result[j * 4 + i] = matrix.m[i][j];
+      result[j * 4 + i] = matrix[i][j];
     }
   }
   return result;
 }
 
 // This code is adapted from the GVR Treasure Hunt demo source.
-gvr::Rectf ModulateRect(const gvr::Rectf& rect, float width, float height) {
-  gvr::Rectf result = {rect.left * width, rect.right * width,
-                       rect.bottom * height, rect.top * height};
-  return result;
-}
-
-// This code is adapted from the GVR Treasure Hunt demo source.
-gvr::Recti CalculatePixelSpaceRect(const gvr::Sizei& texture_size,
-                                   const gvr::Rectf& texture_rect) {
-  float width = static_cast<float>(texture_size.width);
-  float height = static_cast<float>(texture_size.height);
-  gvr::Rectf rect = ModulateRect(texture_rect, width, height);
-  gvr::Recti result = {
-      static_cast<int>(rect.left), static_cast<int>(rect.right),
-      static_cast<int>(rect.bottom), static_cast<int>(rect.top)};
-  return result;
+gfx::Rect CalculatePixelSpaceRect(const gfx::Size& texture_size,
+                                  const gfx::RectF& texture_rect) {
+  const gfx::RectF rect =
+      ScaleRect(texture_rect, static_cast<float>(texture_size.width()),
+                static_cast<float>(texture_size.height()));
+  return gfx::Rect(rect.x(), rect.y(), rect.width(), rect.height());
 }
 
 GLuint CompileShader(GLenum shader_type,
                      const GLchar* shader_source,
                      std::string& error) {
   GLuint shader_handle = glCreateShader(shader_type);
   if (shader_handle != 0) {
     // Pass in the shader source.
     int len = strlen(shader_source);
     glShaderSource(shader_handle, 1, &shader_source, &len);
@@ skipping 50 matching lines @@
       delete[] str_info_log;
       glDeleteProgram(program_handle);
       program_handle = 0;
     }
   }
 
   return program_handle;
 }
 
 }  // namespace vr_shell