Adding support for per vertex opacity on textured layer

cc/heads_up_display_layer_impl.cc

 // Copyright 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 "cc/heads_up_display_layer_impl.h"
 
 #include <limits>
 
 #include "base/stringprintf.h"
 #include "cc/debug_colors.h"
@@ skipping 73 matching lines @@
 {
     if (!m_hudTexture->id())
         return;
 
     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
     gfx::Rect quadRect(gfx::Point(), bounds());
     gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
     bool premultipliedAlpha = true;
     gfx::RectF uvRect(0, 0, 1, 1);
+    const float vertex_opacity[] = {1, 1, 1, 1};

[whunt, 2012/12/14 21:13:45]

Just a note about 'const'.
If you're worried you or someone else might change this value at some point,
const is a reasonable way to prevent that.  The compiler however ignores 'const'
with respect to any optimizations.  Basically the reason is that the compiler
can tell if you change it or not and const doesn't actually prevent you from
changing const values.  The result is that most of the time 'const' is extra
text that enforces a behavior that a reasonable programmer isn't going to break
without good reason anyway.

Just remember:
((float*)vertex_opacity)[1] = 0.5f; is totally legal C.

[enne (OOO), 2012/12/14 21:21:05]

I find const to be good for communicating expectations for how something will be
used.  const on a member function says that this function is not intended to
modify an object.  Sure, somebody could const_cast it away just like you can use
pointers in your example, but it's really about communicating expectations, not
an absolute enforcement.

I think the same thing holds for locals.  It's just communication that you're
declaring something in a temporary variable.  You're saying that you're not
planning to modify it later, but this variable is just here because it's more
readable to separate it out from usage.

     bool flipped = false;
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
-    quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped);
+    quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, vertex_opacity, flipped);
     quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvider)
 {
     if (!m_hudTexture->id())
         return;
 
     SkISize canvasSize;
     if (m_hudCanvas)
@@ skipping 268 matching lines @@
 
     canvas->restore();
 }
 
 const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }  // namespace cc