Support multiple null GL contexts on a thread.

samplecode/SampleApp.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 170 matching lines @@
 
         fBackend = kNone_BackEndType;
 
 #if SK_SUPPORT_GPU
         switch (win->getDeviceType()) {
             case kRaster_DeviceType:
                 // fallthrough
             case kPicture_DeviceType:
                 // fallthrough
             case kGPU_DeviceType:
-                // fallthrough
-            case kNullGPU_DeviceType:
                 // all these guys use the native backend
                 fBackend = kNativeGL_BackEndType;
                 break;
 #if SK_ANGLE
             case kANGLE_DeviceType:
                 // ANGLE is really the only odd man out
                 fBackend = kANGLE_BackEndType;
                 break;
 #endif // SK_ANGLE
             default:
@@ skipping 17 matching lines @@
                 // fallthrough
             case kGPU_DeviceType:
                 // all these guys use the native interface
                 glInterface.reset(GrGLCreateNativeInterface());
                 break;
 #if SK_ANGLE
             case kANGLE_DeviceType:
                 glInterface.reset(GrGLCreateANGLEInterface());
                 break;
 #endif // SK_ANGLE
-            case kNullGPU_DeviceType:
-                glInterface.reset(GrGLCreateNullInterface());
-                break;
             default:
                 SkASSERT(false);
                 break;
         }
 
         // Currently SampleApp does not use NVPR. TODO: Provide an NVPR device type that is skipped
         // when the driver doesn't support NVPR.
         fCurIntf = GrGLInterfaceRemoveNVPR(glInterface.get());
 
         SkASSERT(NULL == fCurContext);
@@ skipping 430 matching lines @@
 }
 
 static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) {
     static const SampleWindow::DeviceType gCT[] = {
         SampleWindow::kPicture_DeviceType,
 #if SK_SUPPORT_GPU
         SampleWindow::kGPU_DeviceType,
 #if SK_ANGLE
         SampleWindow::kANGLE_DeviceType,
 #endif // SK_ANGLE
-        SampleWindow::kRaster_DeviceType, // skip the null gpu device in normal cycling
 #endif // SK_SUPPORT_GPU
         SampleWindow::kRaster_DeviceType
     };
     SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gCT) == SampleWindow::kDeviceTypeCnt, array_size_mismatch);
     return gCT[ct];
 }
 
 static SkString getSampleTitle(const SkViewFactory* sampleFactory) {
     SkView* view = (*sampleFactory)();
     SkString title;
@@ skipping 557 matching lines @@
         }
         name.append(".pdf");
 #ifdef SK_BUILD_FOR_ANDROID
         name.prepend("/sdcard/");
 #endif
         fPDFDocument.reset(SkDocument::CreatePDF(name.c_str()));
         canvas = fPDFDocument->beginPage(this->width(), this->height());
     } else if (kPicture_DeviceType == fDeviceType) {
         canvas = fRecorder.beginRecording(9999, 9999, NULL, 0);
     } else {
-#if SK_SUPPORT_GPU
-        if (kNullGPU_DeviceType != fDeviceType)
-#endif
-        {
-            canvas = this->INHERITED::beforeChildren(canvas);
-        }
+        canvas = this->INHERITED::beforeChildren(canvas);
     }
 
     if (fUseClip) {
         canvas->drawColor(0xFFFF88FF);
         canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true);
     }
 
     return canvas;
 }
 #include "SkMultiPictureDraw.h"
@@ skipping 440 matching lines @@
             fRotate = !fRotate;
             this->inval(NULL);
             this->updateTitle();
             return true;
         case 'k':
             fPerspAnim = !fPerspAnim;
             this->inval(NULL);
             this->updateTitle();
             return true;
 #if SK_SUPPORT_GPU
-        case '\\':
-            this->setDeviceType(kNullGPU_DeviceType);
-            this->inval(NULL);
-            this->updateTitle();
-            return true;
         case 'p':
             {
                 GrContext* grContext = this->getGrContext();
                 if (grContext) {
                     size_t cacheBytes;
                     grContext->getResourceCacheUsage(NULL, &cacheBytes);
                     grContext->freeGpuResources();
                     SkDebugf("Purged %d bytes from the GPU resource cache.\n", cacheBytes);
                 }
             }
@@ skipping 212 matching lines @@
 }
 
 static const char* gDeviceTypePrefix[] = {
     "raster: ",
     "picture: ",
 #if SK_SUPPORT_GPU
     "opengl: ",
 #if SK_ANGLE
     "angle: ",
 #endif // SK_ANGLE
-    "null-gl: "
 #endif // SK_SUPPORT_GPU
 };
 SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gDeviceTypePrefix) == SampleWindow::kDeviceTypeCnt,
                   array_size_mismatch);
 
 static const char* trystate_str(SkOSMenu::TriState state,
                                 const char trueStr[], const char falseStr[]) {
     if (SkOSMenu::kOnState == state) {
         return trueStr;
     } else if (SkOSMenu::kOffState == state) {
@@ skipping 414 matching lines @@
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }