ash: Map/unmap GMB for each laser pointer update.

ash/laser/laser_pointer_view.cc

 // Copyright 2016 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 "ash/laser/laser_pointer_view.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 225 matching lines @@
   widget_->Show();
   widget_->SetContentsView(this);
   widget_->SetBounds(root_window->GetBoundsInScreen());
   set_owned_by_client();
 
   scale_factor_ = display::Screen::GetScreen()
                       ->GetDisplayNearestWindow(widget_->GetNativeView())
                       .device_scale_factor();
 }
 
-LaserPointerView::~LaserPointerView() {
-  // Make sure GPU memory buffer is unmapped before being destroyed.
-  if (gpu_memory_buffer_)
-    gpu_memory_buffer_->Unmap();
-}
+LaserPointerView::~LaserPointerView() {}
 
 void LaserPointerView::Stop() {
   buffer_damage_rect_.Union(GetBoundingBox());
   laser_points_.Clear();
   predicted_laser_points_.Clear();
   OnPointsUpdated();
 }
 
 void LaserPointerView::AddNewPoint(const gfx::PointF& new_point,
                                    const base::TimeTicks& new_time) {
@@ skipping 202 matching lines @@
                 gfx::ScaleToCeiledSize(screen_bounds.size(), scale_factor_),
                 SK_B32_SHIFT ? gfx::BufferFormat::RGBA_8888
                              : gfx::BufferFormat::BGRA_8888,
                 gfx::BufferUsage::SCANOUT_CPU_READ_WRITE,
                 gpu::kNullSurfaceHandle);
     if (!gpu_memory_buffer_) {
       LOG(ERROR) << "Failed to allocate GPU memory buffer";
       return;
     }
 
-    // Map buffer and keep it mapped until destroyed.
-    bool rv = gpu_memory_buffer_->Map();
-    if (!rv) {
-      LOG(ERROR) << "Failed to map GPU memory buffer";
-      return;
-    }
-
     // Make sure the first update rectangle covers the whole buffer.
     update_rect = gfx::Rect(screen_bounds.size());
   }
 
   // Constrain update rectangle to buffer size and early out if empty.
   update_rect.Intersect(gfx::Rect(screen_bounds.size()));
   if (update_rect.IsEmpty())
     return;
 
+  // Map buffer for writing.
+  if (!gpu_memory_buffer_->Map()) {
+    LOG(ERROR) << "Failed to map GPU memory buffer";
+    return;
+  }
+
   // Create a temporary canvas for update rectangle.
   gfx::Canvas canvas(update_rect.size(), scale_factor_, false);
 
   cc::PaintFlags flags;
   flags.setStyle(cc::PaintFlags::kFill_Style);
   flags.setAntiAlias(true);
 
   // Compute the offset of the current widget.
   gfx::Vector2d widget_offset(
       widget_->GetNativeView()->GetBoundsInRootWindow().origin().x(),
@@ skipping 66 matching lines @@
     // Convert update rectangle to pixel coordinates.
     gfx::Rect pixel_rect =
         gfx::ScaleToEnclosingRect(update_rect, scale_factor_);
     uint8_t* data = static_cast<uint8_t*>(gpu_memory_buffer_->memory(0));
     int stride = gpu_memory_buffer_->stride(0);
     canvas.sk_canvas()->readPixels(
         SkImageInfo::MakeN32Premul(pixel_rect.width(), pixel_rect.height()),
         data + pixel_rect.y() * stride + pixel_rect.x() * 4, stride, 0, 0);
   }
 
+  // Unmap to flush writes to buffer.
+  gpu_memory_buffer_->Unmap();
+
   // Update surface damage rectangle.
   surface_damage_rect_.Union(update_rect);
 
   needs_update_surface_ = true;
 
   // Early out if waiting for last surface update to be drawn.
   if (pending_draw_surface_)
     return;
 
   UpdateSurface();
@@ skipping 127 matching lines @@
   pending_draw_surface_ = true;
 }
 
 void LaserPointerView::OnDidDrawSurface() {
   pending_draw_surface_ = false;
   if (needs_update_surface_)
     UpdateSurface();
 }
 
 }  // namespace ash