Revert "Turn NVPR on by default (but off in tools)."

src/gpu/gl/GrGLExtensions.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLExtensions.h"
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLUtil.h"
 
 #include "SkTSearch.h"
 #include "SkTSort.h"
 
-namespace { // This cannot be static because it is used as a template parameter.
+namespace {
 inline bool extension_compare(const SkString& a, const SkString& b) {
     return strcmp(a.c_str(), b.c_str()) < 0;
 }
 }
 
-// finds the index of ext in strings or a negative result if ext is not found.
-static int find_string(const SkTArray<SkString>& strings, const char ext[]) {
-    if (strings.empty()) {
-        return -1;
-    }
-    SkString extensionStr(ext);
-    int idx = SkTSearch<SkString, extension_compare>(&strings.front(),
-                                                     strings.count(),
-                                                     extensionStr,
-                                                     sizeof(SkString));
-    return idx;
-}
-
-GrGLExtensions::GrGLExtensions(const GrGLExtensions& that) : fStrings(SkNEW(SkTArray<SkString>)) {
-    *this = that;
-}
-
-GrGLExtensions& GrGLExtensions::operator=(const GrGLExtensions& that) {
-    *fStrings = *that.fStrings;
-    fInitialized = that.fInitialized;
-    return *this;
-}
-
 bool GrGLExtensions::init(GrGLStandard standard,
                           GrGLGetStringProc getString,
                           GrGLGetStringiProc getStringi,
                           GrGLGetIntegervProc getIntegerv) {
     fInitialized = false;
     fStrings->reset();
 
     if (NULL == getString) {
         return false;
     }
@@ skipping 38 matching lines @@
         }
     }
     if (!fStrings->empty()) {
         SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;
         SkTQSort(&fStrings->front(), &fStrings->back(), cmp);
     }
     fInitialized = true;
     return true;
 }
 
-bool GrGLExtensions::has(const char ext[]) const {
-    SkASSERT(fInitialized);
-    return find_string(*fStrings, ext) >= 0;
-}
-
-bool GrGLExtensions::remove(const char ext[]) {
-    SkASSERT(fInitialized);
-    int idx = find_string(*fStrings, ext);
-    if (idx >= 0) {
-        // This is not terribly effecient but we really only expect this function to be called at
-        // most a handful of times when our test programs start.
-        SkAutoTDelete< SkTArray<SkString> > oldStrings(fStrings.detach());
-        fStrings.reset(SkNEW(SkTArray<SkString>(oldStrings->count() - 1)));
-        fStrings->push_back_n(idx, &oldStrings->front());
-        fStrings->push_back_n(oldStrings->count() - idx - 1, &(*oldStrings)[idx] + 1);
-        return true;
-    } else {
+bool GrGLExtensions::has(const char* ext) const {
+    if (fStrings->empty()) {
         return false;
     }
+    SkString extensionStr(ext);
+    int idx = SkTSearch<SkString, extension_compare>(&fStrings->front(),
+                                                     fStrings->count(),
+                                                     extensionStr,
+                                                     sizeof(SkString));
+    return idx >= 0;
 }
 
 void GrGLExtensions::print(const char* sep) const {
     if (NULL == sep) {
         sep = " ";
     }
     int cnt = fStrings->count();
     for (int i = 0; i < cnt; ++i) {
         GrPrintf("%s%s", (*fStrings)[i].c_str(), (i < cnt - 1) ? sep : "");
     }
 }