Moved the logic of maintaining the current context to gles2 helper library.

gpu/demos/framework/pepper.cc

 // Copyright (c) 2010 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 <GLES2/gl2.h>
+
 #include "base/at_exit.h"
 #include "base/scoped_ptr.h"
 #include "gpu/demos/framework/demo.h"
 #include "gpu/demos/framework/demo_factory.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/dev/graphics_3d_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
+#include "ppapi/lib/gl/gles2/gl2ext_ppapi.h"
 
 namespace gpu {
 namespace demos {
 
 class PluginInstance : public pp::Instance {
  public:
   PluginInstance(PP_Instance instance, pp::Module* module)
       : pp::Instance(instance),
         module_(module),
         demo_(CreateDemo()) {
     // Set the callback object outside of the initializer list to avoid a
     // compiler warning about using "this" in an initializer list.
     callback_factory_.Initialize(this);
   }
 
   ~PluginInstance() {
     if (!graphics_.is_null()) {
-      graphics_.MakeCurrent();
+      glSetCurrentContextPPAPI(graphics_.pp_resource());

[apatrick_chromium, 2010/12/16 22:46:00]

Unrelated to this patch and an aside but this naming convention makes these
functions look like they are part of a GL extension. The function to set the GL
context is not normally implemented as what Khronos calls a "native platform
graphics interface" like EGL.

[alokp, 2010/12/20 17:24:40]

If we have to keep GLES2 lib independent of EGL lib then I need a hook to set
the current context to be used by the GLES2 lib. Modeling these extra functions
as extensions seemed like a good thing but may be confusing. Fortunately the
clients will never have to use these functions if they are using EGL library.

       demo_.reset();
-      pp::Graphics3D_Dev::ResetCurrent();
+      glSetCurrentContextPPAPI(0);
     }
   }
 
   virtual void DidChangeView(const pp::Rect& position,
                              const pp::Rect& /*clip*/) {
     if (size_ == position.size())
       return;
 
     size_ = position.size();
     demo_->InitWindowSize(size_.width(), size_.height());
 
     if (graphics_.is_null()) {
       graphics_ = pp::Graphics3D_Dev(*this, 0, NULL, NULL);
       if (graphics_.is_null())
         return;
 
       if (!pp::Instance::BindGraphics(graphics_))
         return;
 
-      graphics_.MakeCurrent();
+      glSetCurrentContextPPAPI(graphics_.pp_resource());
       demo_->InitGL();
-      pp::Graphics3D_Dev::ResetCurrent();
+      glSetCurrentContextPPAPI(0);
     }
 
     if (demo_->IsAnimated())
       Animate(0);
     else
       Paint();
   }
 
   void Paint() {
-    graphics_.MakeCurrent();
+    glSetCurrentContextPPAPI(graphics_.pp_resource());
     demo_->Draw();
     graphics_.SwapBuffers();
-    pp::Graphics3D_Dev::ResetCurrent();
+    glSetCurrentContextPPAPI(0);
   }
 
  private:
   void Animate(int delay) {
     Paint();
     module_->core()->CallOnMainThread(delay,
         callback_factory_.NewCallback(&PluginInstance::Animate), delay);
   }
 
   pp::Module* module_;
   scoped_ptr<Demo> demo_;
   pp::Graphics3D_Dev graphics_;
   pp::Size size_;
   pp::CompletionCallbackFactory<PluginInstance> callback_factory_;
 };
 
 class PluginModule : public pp::Module {
  public:
-  PluginModule() : pp::Module(), at_exit_manager_(new base::AtExitManager) {}
+  PluginModule() : at_exit_manager_(new base::AtExitManager) {}
+  ~PluginModule() {
+    glTerminatePPAPI();
+  }
+
+  virtual bool Init() {
+    return glInitializePPAPI(get_browser_interface()) == GL_TRUE ? true : false;
+  }
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new PluginInstance(instance, this);
   }
 
  private:
   scoped_ptr<base::AtExitManager> at_exit_manager_;
 };
 
 }  // namespace demos
 }  // namespace gpu
 
 namespace pp {
 
 Module* CreateModule() {
   return new gpu::demos::PluginModule();
 }
 
 }  // namespace pp