cc: Partial tile update for one-copy raster.

ui/compositor/compositor.cc

 // Copyright (c) 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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
       command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
   settings.initial_debug_state.show_replica_screen_space_rects =
       command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
 
   settings.initial_debug_state.SetRecordRenderingStats(
       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 
   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
   settings.use_display_lists = IsUISlimmingPaintEnabled();
   settings.use_cached_picture_in_display_list = false;
+
   settings.use_zero_copy = IsUIZeroCopyEnabled();
   settings.use_one_copy = IsUIOneCopyEnabled();
-  settings.use_image_texture_target = context_factory_->GetImageTextureTarget();
+
+  // TODO(reveman): We currently assume that the compositor will use BGRA_8888
+  // if it's able to, and RGBA_8888 otherwise. Since we don't know what it will
+  // use we hardcode BGRA_8888 here for now. We should instead
+  // move decisions about GpuMemoryBuffer format to the browser embedder so we
+  // know it here, and pass that decision to the compositor for each usage.
+  // crbug.com/490362
+  gfx::GpuMemoryBuffer::Format format = gfx::GpuMemoryBuffer::BGRA_8888;
+  gfx::GpuMemoryBuffer::Usage usage = gfx::GpuMemoryBuffer::MAP;
+
+  // Use PERSISTENT_MAP memory buffers to support partial tile updates in the
+  // one-copy implementation.
+  if (IsUIOneCopyEnabled()) {

[reveman, 2015/05/22 17:15:13]

What if IsUIZeroCopyEnabled() is also enabled? With this code we'd have to use
zero-copy with map-persistent usage too, which is fine but I'm guessing not what
you intended.

[danakj, 2015/05/26 19:02:52]

If zero copy is enabled, then one copy is disabled, and we'd use MAP instead.
No?

[reveman, 2015/05/26 20:12:37]

Ah, didn't realize that we have checks inside these functions that prevent both
from being enabled at the same time. That's a bit weird considering that
one-copy will soon be removed as an option. I'd avoid using IsUIOneCopyEnabled
for anything other than turning on one-copy.

I think we can just remove this check. If we need partial updates for good UI
compositor performance then let's always turn it on here. If it turns out that
there is some device out there where we need to disable this then we can
introduce a command line switch for it if necessary.

[danakj, 2015/05/26 20:17:37]

But there's no point turning it on for zero copy if the zero copy worker pool
doesn't support it. I have the check here because that's the only worker pool
that has support. I'd remove it when zero copy also supports it. I can add a
TODO? Or I can remove the check if you prefer.

[danakj, 2015/05/26 23:37:34]

Done.

+    usage = gfx::GpuMemoryBuffer::PERSISTENT_MAP;
+    settings.have_persistent_gpu_memory_buffers = true;
+  }
+  settings.use_image_texture_target =
+      context_factory_->GetImageTextureTarget(format, usage);
+
   // Note: gathering of pixel refs is only needed when using multiple
   // raster threads.
   settings.gather_pixel_refs = false;
 
   settings.use_compositor_animation_timelines =
       command_line->HasSwitch(switches::kUIEnableCompositorAnimationTimelines);
 
   base::TimeTicks before_create = base::TimeTicks::Now();
 
   cc::LayerTreeHost::InitParams params;
@@ skipping 286 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui