Remove WGC3D::isContextLost references from cc

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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 "cc/output/gl_renderer.h"
 
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 39 matching lines @@
 using WebKit::WGC3Dint;
 using WebKit::WGC3Dintptr;
 using WebKit::WGC3Dsizei;
 using WebKit::WGC3Dsizeiptr;
 using WebKit::WGC3Duint;
 
 namespace cc {
 
 #define EXPECT_PROGRAM_VALID(program_binding)                                  \
   do {                                                                         \
-    EXPECT_TRUE(program_binding->program());                                   \
-    EXPECT_TRUE(program_binding->initialized());                               \
+    EXPECT_TRUE((program_binding)->program());                                 \
+    EXPECT_TRUE((program_binding)->initialized());                             \
   } while (false)
 
 // Explicitly named to be a friend in GLRenderer for shader access.
 class GLRendererShaderPixelTest : public GLRendererPixelTest {
  public:
   void TestShaders() {
     ASSERT_FALSE(renderer()->IsContextLost());
     EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());
@@ skipping 183 matching lines @@
     resource_provider_ = ResourceProvider::Create(
         output_surface_.get(), NULL, 0, false, 1).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
   }
 
   void TestRenderPassProgram() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_program_);
-    EXPECT_EQ(renderer_->render_pass_program_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_);
+    EXPECT_EQ(renderer_->render_pass_program_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgram() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_color_matrix_program_);
-    EXPECT_EQ(renderer_->render_pass_color_matrix_program_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_color_matrix_program_);
+    EXPECT_EQ(renderer_->render_pass_color_matrix_program_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskProgram() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_mask_program_);
-    EXPECT_EQ(renderer_->render_pass_mask_program_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_);
+    EXPECT_EQ(renderer_->render_pass_mask_program_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskColorMatrixProgram() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_mask_color_matrix_program_);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_);
+    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassProgramAA() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_program_aa_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_aa_);
+    EXPECT_EQ(renderer_->render_pass_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgramAA() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_color_matrix_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_color_matrix_program_aa_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_color_matrix_program_aa_);
+    EXPECT_EQ(renderer_->render_pass_color_matrix_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskProgramAA() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_mask_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_mask_program_aa_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_aa_);
+    EXPECT_EQ(renderer_->render_pass_mask_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskColorMatrixProgramAA() {
-    EXPECT_PROGRAM_VALID(renderer_->render_pass_mask_color_matrix_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_aa_);
+    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   void TestSolidColorProgramAA() {
-    EXPECT_PROGRAM_VALID(renderer_->solid_color_program_aa_);
-    EXPECT_EQ(renderer_->solid_color_program_aa_->program(),
+    EXPECT_PROGRAM_VALID(&renderer_->solid_color_program_aa_);
+    EXPECT_EQ(renderer_->solid_color_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
@@ skipping 238 matching lines @@
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
-  LoseContextOnFirstGetContext() : context_lost_(false) {}
-
-  virtual bool makeContextCurrent() OVERRIDE { return !context_lost_; }
+  LoseContextOnFirstGetContext() {}
 
   virtual void getProgramiv(WebGLId program, WGC3Denum pname, WGC3Dint* value)
       OVERRIDE {
     context_lost_ = true;
     *value = 0;
   }
 
   virtual void getShaderiv(WebGLId shader, WGC3Denum pname, WGC3Dint* value)
       OVERRIDE {
     context_lost_ = true;
     *value = 0;
   }
-
-  virtual WGC3Denum getGraphicsResetStatusARB() OVERRIDE {
-    return context_lost_ ? 1 : 0;
-  }
-
- private:
-  bool context_lost_;
 };
 
 TEST(GLRendererTest2, InitializationWithQuicklyLostContextDoesNotAssert) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<TestWebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
@@ skipping 1180 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc