Added some tracing to VrShell

chrome/browser/android/vr_shell/vr_shell.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_shell.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
@@ skipping 513 matching lines @@
     gesture->data.tapDown.height = pixel_y;
     current_input_target_->ProcessUpdatedGesture(*gesture.get());
   }
 }
 
 void VrShell::SetGvrPoseForWebVr(const gvr::Mat4f& pose, uint32_t pose_num) {
   webvr_head_pose_[pose_num % kPoseRingBufferSize] = pose;
 }
 
 uint32_t GetPixelEncodedPoseIndex() {
+  TRACE_EVENT0("gpu", "VrShell::GetPixelEncodedPoseIndex");
   // Read the pose index encoded in a bottom left pixel as color values.
   // See also third_party/WebKit/Source/modules/vr/VRDisplay.cpp which
   // encodes the pose index, and device/vr/android/gvr/gvr_device.cc
   // which tracks poses.
   uint8_t pixels[4];
   // Assume we're reading from the framebuffer we just wrote to.
   // That's true currently, we may need to use glReadBuffer(GL_BACK)
   // or equivalent if the rendering setup changes in the future.
   glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   return pixels[0] | (pixels[1] << 8) | (pixels[2] << 16);
 }
 
 void VrShell::DrawFrame(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+  TRACE_EVENT0("gpu", "VrShell::DrawFrame");
   // Reset the viewport list to just the pair of viewports for the
   // primary buffer each frame. Head-locked viewports get added by
   // DrawVrShell if needed.
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     // If needed, resize the primary buffer for use with WebVR.
     if (render_size_primary_ != render_size_primary_webvr_) {
       render_size_primary_ = render_size_primary_webvr_;
       swap_chain_->ResizeBuffer(kFramePrimaryBuffer, render_size_primary_);
@@ skipping 59 matching lines @@
   }
 
   DrawVrShell(head_pose, frame);
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose);
 }
 
 void VrShell::DrawVrShell(const gvr::Mat4f& head_pose,
                           gvr::Frame &frame) {
+  TRACE_EVENT0("gpu", "VrShell::DrawVrShell");
   std::vector<const ContentRectangle*> head_locked_elements;
   std::vector<const ContentRectangle*> world_elements;
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->visible) {
       continue;
     }
     if (rect->lock_to_fov) {
       head_locked_elements.push_back(rect.get());
     } else {
       world_elements.push_back(rect.get());
@@ skipping 53 matching lines @@
   // This is a stopgap while we're using the WebVR compositor rendering path.
   // TODO(klausw,crbug.com/655722): Remove this method and member once we're
   // using a separate WebVR render surface.
   return content_tex_pixels_for_webvr_;
 }
 
 
 void VrShell::DrawUiView(const gvr::Mat4f* head_pose,
                          const std::vector<const ContentRectangle*>& elements,
                          const gvr::Sizei& render_size, int viewport_offset) {
+  TRACE_EVENT0("gpu", "VrShell::DrawUiView");
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(
         eye + viewport_offset, buffer_viewport_.get());
 
     gvr::Mat4f view_matrix = gvr_api_->GetEyeFromHeadMatrix(eye);
     if (head_pose != nullptr) {
       view_matrix = MatrixMul(view_matrix, *head_pose);
     }
 
     gvr::Recti pixel_rect =
@@ skipping 107 matching lines @@
     // Move the beam origin to the hand.
     TranslateM(face_transform, face_transform, kHandPosition.x, kHandPosition.y,
                kHandPosition.z);
 
     transform = MatrixMul(render_matrix, face_transform);
     vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
   }
 }
 
 void VrShell::DrawWebVr() {
+  TRACE_EVENT0("gpu", "VrShell::DrawWebVr");
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_BLEND);
   glDisable(GL_POLYGON_OFFSET_FILL);
 
   glViewport(0, 0, render_size_primary_.width, render_size_primary_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(webvr_texture_id_);
@@ skipping 73 matching lines @@
 
 gvr::GvrApi* VrShell::gvr_api() {
   return gvr_api_.get();
 }
 
 void VrShell::ContentSurfaceChanged(JNIEnv* env,
                                     const JavaParamRef<jobject>& object,
                                     jint width,
                                     jint height,
                                     const JavaParamRef<jobject>& surface) {
+  TRACE_EVENT0("gpu", "VrShell::ContentSurfaceChanged");
   // If we have a delegate, must trigger "ready" callback one time only.
   // Do so the first time we got a nonzero size. (This assumes it doesn't
   // change, but once we get resize ability we'll no longer need this hack.)
   // TODO(klausw,crbug.com/655722): remove when we have surface support.
   bool delegate_not_ready = delegate_ && !content_tex_pixels_for_webvr_.width;
 
   content_compositor_->SurfaceChanged((int)width, (int)height, surface);
   content_tex_pixels_for_webvr_.width = width;
   content_tex_pixels_for_webvr_.height = height;
   float scale_factor = display::Screen::GetScreen()
@@ skipping 99 matching lines @@
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell