Rename from "(un)lock" to "(un)map" for geometry buffers.

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 32 matching lines @@
 static const size_t kQuadIdxSBufize = kIdxsPerQuad *
                                       sizeof(uint16_t) *
                                       kNumQuadsInIdxBuffer;
 
 static const int kNumLineSegsInIdxBuffer = 256;
 static const size_t kLineSegIdxSBufize = kIdxsPerLineSeg *
                                          sizeof(uint16_t) *
                                          kNumLineSegsInIdxBuffer;
 
 static bool push_quad_index_data(GrIndexBuffer* qIdxBuffer) {
-    uint16_t* data = (uint16_t*) qIdxBuffer->lock();
+    uint16_t* data = (uint16_t*) qIdxBuffer->map();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumQuadsInIdxBuffer * kIdxsPerQuad);
     }
     for (int i = 0; i < kNumQuadsInIdxBuffer; ++i) {
 
         // Each quadratic is rendered as a five sided polygon. This poly bounds
         // the quadratic's bounding triangle but has been expanded so that the
         // 1-pixel wide area around the curve is inside the poly.
         // If a,b,c are the original control points then the poly a0,b0,c0,c1,a1
@@ skipping 15 matching lines @@
         data[5 + baseIdx] = baseVert + 3; // c0
         data[6 + baseIdx] = baseVert + 1; // a1
         data[7 + baseIdx] = baseVert + 4; // c1
         data[8 + baseIdx] = baseVert + 2; // b0
     }
     if (tempData) {
         bool ret = qIdxBuffer->updateData(data, kQuadIdxSBufize);
         delete[] data;
         return ret;
     } else {
-        qIdxBuffer->unlock();
+        qIdxBuffer->unmap();
         return true;
     }
 }
 
 static bool push_line_index_data(GrIndexBuffer* lIdxBuffer) {
-    uint16_t* data = (uint16_t*) lIdxBuffer->lock();
+    uint16_t* data = (uint16_t*) lIdxBuffer->map();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumLineSegsInIdxBuffer * kIdxsPerLineSeg);
     }
     for (int i = 0; i < kNumLineSegsInIdxBuffer; ++i) {
         // Each line segment is rendered as two quads and two triangles.
         // p0 and p1 have alpha = 1 while all other points have alpha = 0.
         // The four external points are offset 1 pixel perpendicular to the
         // line and half a pixel parallel to the line.
         //
@@ skipping 26 matching lines @@
 
         data[15 + baseIdx] = baseVert + 1;
         data[16 + baseIdx] = baseVert + 5;
         data[17 + baseIdx] = baseVert + 3;
     }
     if (tempData) {
         bool ret = lIdxBuffer->updateData(data, kLineSegIdxSBufize);
         delete[] data;
         return ret;
     } else {
-        lIdxBuffer->unlock();
+        lIdxBuffer->unmap();
         return true;
     }
 }
 }
 
 GrPathRenderer* GrAAHairLinePathRenderer::Create(GrContext* context) {
     GrGpu* gpu = context->getGpu();
     GrIndexBuffer* qIdxBuf = gpu->createIndexBuffer(kQuadIdxSBufize, false);
     SkAutoTUnref<GrIndexBuffer> qIdxBuffer(qIdxBuf);
     if (NULL == qIdxBuf || !push_quad_index_data(qIdxBuf)) {
@@ skipping 880 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }