Mojo container example for hosting Pepper plugins

mojo/examples/pepper_container_app/pepper_spinning_cube_demo/spinning_cube.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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.
 
 // This example program is based on Simple_VertexShader.c from:
 
 //
 // Book:      OpenGL(R) ES 2.0 Programming Guide
 // Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 // ISBN-10:   0321502795
 // ISBN-13:   9780321502797
 // Publisher: Addison-Wesley Professional
 // URLs:      http://safari.informit.com/9780321563835
 //            http://www.opengles-book.com
 //
 
-#include "mojo/examples/sample_app/spinning_cube.h"
+#include "mojo/examples/pepper_container_app/pepper_spinning_cube_demo/spinning_cube.h"
 
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
+
+#include <algorithm>
+
+#include "ppapi/lib/gl/include/GLES2/gl2.h"
 
 namespace mojo {
 namespace examples {
 
 namespace {
 
 const float kPi = 3.14159265359f;
 
 int GenerateCube(GLuint *vbo_vertices,
                  GLuint *vbo_indices) {
@@ skipping 312 matching lines @@
 
 SpinningCube::~SpinningCube() {
   if (!initialized_)
     return;
   if (state_->vbo_vertices_)
     glDeleteBuffers(1, &state_->vbo_vertices_);
   if (state_->vbo_indices_)
     glDeleteBuffers(1, &state_->vbo_indices_);
   if (state_->program_object_)
     glDeleteProgram(state_->program_object_);
+
+  delete state_;
 }
 
 void SpinningCube::Init(uint32_t width, uint32_t height) {
   width_ = width;
   height_ = height;
 
-  const char vertext_shader_source[] =
-      "uniform mat4 u_mvpMatrix;                   \n"
-      "attribute vec4 a_position;                  \n"
-      "void main()                                 \n"
-      "{                                           \n"
-      "   gl_Position = u_mvpMatrix * a_position;  \n"
-      "}                                           \n";
+  if (!initialized_) {
+    initialized_ = true;
+    const char vertext_shader_source[] =
+        "uniform mat4 u_mvpMatrix;                   \n"
+        "attribute vec4 a_position;                  \n"
+        "void main()                                 \n"
+        "{                                           \n"
+        "   gl_Position = u_mvpMatrix * a_position;  \n"
+        "}                                           \n";
 
-  const char fragment_shader_source[] =
-      "precision mediump float;                            \n"
-      "void main()                                         \n"
-      "{                                                   \n"
-      "  gl_FragColor = vec4( 0.0, 1.0, 0.0, 1.0 );        \n"
-      "}                                                   \n";
+    const char fragment_shader_source[] =
+        "precision mediump float;                            \n"
+        "void main()                                         \n"
+        "{                                                   \n"
+        "  gl_FragColor = vec4( 0.0, 0.0, 1.0, 1.0 );        \n"
+        "}                                                   \n";
 
-  state_->program_object_ = LoadProgram(
-      vertext_shader_source, fragment_shader_source);
-  state_->position_location_ = glGetAttribLocation(
-      state_->program_object_, "a_position");
-  state_->mvp_location_ = glGetUniformLocation(
-      state_->program_object_, "u_mvpMatrix");
-  state_->num_indices_ = GenerateCube(
-      &state_->vbo_vertices_, &state_->vbo_indices_);
+    state_->program_object_ = LoadProgram(
+        vertext_shader_source, fragment_shader_source);
+    state_->position_location_ = glGetAttribLocation(
+        state_->program_object_, "a_position");
+    state_->mvp_location_ = glGetUniformLocation(
+        state_->program_object_, "u_mvpMatrix");
+    state_->num_indices_ = GenerateCube(
+        &state_->vbo_vertices_, &state_->vbo_indices_);
 
-  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-  initialized_ = true;
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+  }
 }
 
 void SpinningCube::OnGLContextLost() {
+  // TODO(yzshen): Is it correct that in this case we don't need to do cleanup
+  // for program and buffers?
   initialized_ = false;
   height_ = 0;
   width_ = 0;
   state_->OnGLContextLost();
 }
 
 void SpinningCube::SetFlingMultiplier(float drag_distance,
                                       float drag_time) {
   fling_multiplier_ = RotationForDragDistance(drag_distance) /
       RotationForTimeDelta(drag_time);
@@ skipping 54 matching lines @@
   ESMatrix modelview;
   modelview.LoadIdentity();
   modelview.Translate(0.0, 0.0, -2.0);
   modelview.Rotate(state_->angle_ * direction_, 1.0, 0.0, 1.0);
 
   state_->mvp_matrix_.Multiply(&modelview, &perspective);
 }
 
 }  // namespace examples
 }  // namespace mojo