cc: Replace FIXMEs with TODO(danakj)

R=danakj@chromium.org
BUG=none

Review URL: https://chromiumcodereview.appspot.com/18050012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@209050 0039d316-1c4b-4281-b951-d872f2087c98

19 files changed, 68 insertions, 69 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 38886aa..31b0a8d 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -190,7 +190,7 @@ void DelegatedRendererLayerImpl::SetRenderPasses(
 }
 
 void DelegatedRendererLayerImpl::ClearRenderPasses() {
-  // FIXME: Release the resources back to the nested compositor.
+  // TODO(danakj): Release the resources back to the nested compositor.
   render_passes_index_by_id_.clear();
   render_passes_in_draw_order_.clear();
 }
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index b888e23..f8577a3 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -40,7 +40,7 @@ void IOSurfaceLayerImpl::DestroyTexture() {
 
   if (io_surface_texture_id_) {
     OutputSurface* output_surface = layer_tree_impl()->output_surface();
-    // FIXME: Implement this path for software compositing.
+    // TODO(skaslev): Implement this path for software compositing.
     WebKit::WebGraphicsContext3D* context3d = output_surface->context3d();
     if (context3d)
       context3d->deleteTexture(io_surface_texture_id_);
@@ -70,11 +70,11 @@ bool IOSurfaceLayerImpl::WillDraw(DrawMode draw_mode,
     WebKit::WebGraphicsContext3D* context3d =
         resource_provider->GraphicsContext3D();
     if (!context3d) {
-      // FIXME: Implement this path for software compositing.
+      // TODO(skaslev): Implement this path for software compositing.
       return false;
     }
 
-    // FIXME: Do this in a way that we can track memory usage.
+    // TODO(ernstm): Do this in a way that we can track memory usage.
     if (!io_surface_texture_id_) {
       io_surface_texture_id_ = context3d->createTexture();
       io_surface_resource_id_ =
diff --git a/cc/layers/nine_patch_layer.cc b/cc/layers/nine_patch_layer.cc
index 7327795..8003f67 100644
--- a/cc/layers/nine_patch_layer.cc
+++ b/cc/layers/nine_patch_layer.cc
@@ -40,8 +40,6 @@ void NinePatchLayer::SetTexturePriorities(
   if (resource_) {
     resource_->texture()->set_request_priority(
         PriorityCalculator::UIPriority(true));
-    // FIXME: Need to support swizzle in the shader for
-    // !PlatformColor::sameComponentOrder(texture_format)
     GLenum texture_format =
         layer_tree_host()->GetRendererCapabilities().best_texture_format;
     resource_->texture()->SetDimensions(
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index fbf224b..5aafb8a 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -172,13 +172,13 @@ void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
     quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
-  // FIXME: By using the same RenderSurfaceImpl for both the content and its
-  // reflection, it's currently not possible to apply a separate mask to the
-  // reflection layer or correctly handle opacity in reflections (opacity must
-  // be applied after drawing both the layer and its reflection). The solution
-  // is to introduce yet another RenderSurfaceImpl to draw the layer and its
-  // reflection in. For now we only apply a separate reflection mask if the
-  // contents don't have a mask of their own.
+  // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
+  // and its reflection, it's currently not possible to apply a separate mask to
+  // the reflection layer or correctly handle opacity in reflections (opacity
+  // must be applied after drawing both the layer and its reflection). The
+  // solution is to introduce yet another RenderSurfaceImpl to draw the layer
+  // and its reflection in. For now we only apply a separate reflection mask if
+  // the contents don't have a mask of their own.
   LayerImpl* mask_layer = owning_layer_->mask_layer();
   if (mask_layer &&
       (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 0c70ba7..c5258cf 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -110,8 +110,8 @@ void TextureLayerImpl::DidDraw(ResourceProvider* resource_provider) {
   LayerImpl::DidDraw(resource_provider);
   if (uses_mailbox_ || !external_texture_resource_)
     return;
-  // FIXME: the following assert will not be true when sending resources to a
-  // parent compositor. A synchronization scheme (double-buffering or
+  // TODO(danakj): the following assert will not be true when sending resources
+  // to a parent compositor. A synchronization scheme (double-buffering or
   // pipelining of updates) for the client will need to exist to solve this.
   DCHECK(!resource_provider->InUseByConsumer(external_texture_resource_));
   resource_provider->DeleteResource(external_texture_resource_);
diff --git a/cc/layers/tiled_layer.cc b/cc/layers/tiled_layer.cc
index a767ee9..f7d1ff9 100644
--- a/cc/layers/tiled_layer.cc
+++ b/cc/layers/tiled_layer.cc
@@ -201,7 +201,7 @@ void TiledLayer::PushPropertiesTo(LayerImpl* layer) {
     int i = iter->first.first;
     int j = iter->first.second;
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
-    // FIXME: This should not ever be null.
+    // TODO(enne): This should not ever be null.
     if (!tile)
       continue;
 
@@ -253,7 +253,7 @@ void TiledLayer::SetLayerTreeHost(LayerTreeHost* host) {
          iter != tiler_->tiles().end();
          ++iter) {
       UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
-      // FIXME: This should not ever be null.
+      // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
       tile->managed_resource()->SetTextureManager(
@@ -301,7 +301,7 @@ void TiledLayer::InvalidateContentRect(gfx::Rect content_rect) {
        ++iter) {
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
     DCHECK(tile);
-    // FIXME: This should not ever be null.
+    // TODO(enne): This should not ever be null.
     if (!tile)
       continue;
     gfx::Rect bound = tiler_->TileRect(tile);
@@ -366,7 +366,7 @@ void TiledLayer::MarkOcclusionsAndRequestTextures(
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorities get skipped?
-      // FIXME: This should not ever be null.
+      // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
       // Did ResetUpdateState get skipped? Are we doing more than one occlusion
@@ -404,7 +404,7 @@ bool TiledLayer::HaveTexturesForTiles(int left,
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
-                     // FIXME: This should not ever be null.
+                     // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
 
@@ -434,12 +434,12 @@ gfx::Rect TiledLayer::MarkTilesForUpdate(int left,
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
-                     // FIXME: This should not ever be null.
+                     // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
       if (tile->occluded && !ignore_occlusions)
         continue;
-      // FIXME: Decide if partial update should be allowed based on cost
+      // TODO(reveman): Decide if partial update should be allowed based on cost
       // of update. https://bugs.webkit.org/show_bug.cgi?id=77376
       if (tile->is_dirty() && layer_tree_host() &&
           layer_tree_host()->buffered_updates()) {
@@ -499,7 +499,7 @@ void TiledLayer::UpdateTileTextures(gfx::Rect paint_rect,
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
-                     // FIXME: This should not ever be null.
+                     // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
 
@@ -586,8 +586,8 @@ bool TiledLayer::IsSmallAnimatedLayer() const {
 }
 
 namespace {
-// FIXME: Remove this and make this based on distance once distance can be
-// calculated for offscreen layers. For now, prioritize all small animated
+// TODO(epenner): Remove this and make this based on distance once distance can
+// be calculated for offscreen layers. For now, prioritize all small animated
 // layers after 512 pixels of pre-painting.
 void SetPriorityForTexture(gfx::Rect visible_rect,
                            gfx::Rect tile_rect,
@@ -643,7 +643,7 @@ void TiledLayer::SetTexturePriorities(const PriorityCalculator& priority_calc) {
        iter != tiler_->tiles().end();
        ++iter) {
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
-    // FIXME: This should not ever be null.
+    // TODO(enne): This should not ever be null.
     if (!tile)
       continue;
     gfx::Rect tile_rect = tiler_->TileRect(tile);
@@ -672,7 +672,7 @@ void TiledLayer::ResetUpdateState() {
        iter != end;
        ++iter) {
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
-    // FIXME: This should not ever be null.
+    // TODO(enne): This should not ever be null.
     if (!tile)
       continue;
     tile->ResetUpdateState();
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index d9729d3..74fe4942 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -296,7 +296,8 @@ void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
 }
 
 void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
-  // FIXME: Remove this once backbuffer is automatically recreated on first use
+  // TODO(aelias): Remove this once backbuffer is automatically recreated on
+  // first use
   EnsureBackbuffer();
 
   if (client_->DeviceViewport().IsEmpty())
@@ -586,22 +587,22 @@ scoped_ptr<ScopedResource> GLRenderer::DrawBackgroundFilters(
   //
   // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
-  // FIXME: When this algorithm changes, update
+  // TODO(danakj): When this algorithm changes, update
   // LayerTreeHost::PrioritizeTextures() accordingly.
 
   FilterOperations filters =
       RenderSurfaceFilters::Optimize(quad->background_filters);
   DCHECK(!filters.IsEmpty());
 
-  // FIXME: We only allow background filters on an opaque render surface because
-  // other surfaces may contain translucent pixels, and the contents behind
-  // those translucent pixels wouldn't have the filter applied.
+  // TODO(danakj): We only allow background filters on an opaque render surface
+  // because other surfaces may contain translucent pixels, and the contents
+  // behind those translucent pixels wouldn't have the filter applied.
   if (frame->current_render_pass->has_transparent_background)
     return scoped_ptr<ScopedResource>();
   DCHECK(!frame->current_texture);
 
-  // FIXME: Do a single readback for both the surface and replica and cache the
-  // filtered results (once filter textures are not reused).
+  // TODO(danakj): Do a single readback for both the surface and replica and
+  // cache the filtered results (once filter textures are not reused).
   gfx::Rect window_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, SharedGeometryQuad().BoundingBox()));
 
@@ -722,8 +723,8 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
       SetBlendEnabled(true);
   }
 
-  // FIXME: Cache this value so that we don't have to do it for both the surface
-  // and its replica.  Apply filters to the contents texture.
+  // TODO(senorblanco): Cache this value so that we don't have to do it for both
+  // the surface and its replica.  Apply filters to the contents texture.
   SkBitmap filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
@@ -794,8 +795,8 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
     mask_texture_id = mask_resource_lock->texture_id();
   }
 
-  // FIXME: use the background_texture and blend the background in with this
-  // draw instead of having a separate copy of the background texture.
+  // TODO(danakj): use the background_texture and blend the background in with
+  // this draw instead of having a separate copy of the background texture.
 
   scoped_ptr<ResourceProvider::ScopedReadLockGL> contents_resource_lock;
   if (filter_bitmap.getTexture()) {
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 18c21cc..27db3a7 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -575,8 +575,8 @@ class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
 
   virtual WebString getString(WGC3Denum name) {
     // We allow querying the extension string.
-    // FIXME: It'd be better to check that we only do this before starting any
-    // other expensive work (like starting a compilation)
+    // TODO(enne): It'd be better to check that we only do this before starting
+    // any other expensive work (like starting a compilation)
     if (name != GL_EXTENSIONS)
       ADD_FAILURE();
     return WebString();
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 4b604a8..1cf221c 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -345,7 +345,7 @@ void SoftwareRenderer::DrawTextureQuad(const DrawingFrame* frame,
     return;
   }
 
-  // FIXME: Add support for non-premultiplied alpha.
+  // TODO(skaslev): Add support for non-premultiplied alpha.
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 quad->resource_id);
   const SkBitmap* bitmap = lock.sk_bitmap();
@@ -436,7 +436,7 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
     current_paint_.setRasterizer(mask_rasterizer.get());
     current_canvas_->drawRect(dest_rect, current_paint_);
   } else {
-    // FIXME: Apply background filters and blend with content
+    // TODO(skaslev): Apply background filters and blend with content
     current_canvas_->drawRect(dest_rect, current_paint_);
   }
 }
diff --git a/cc/resources/layer_tiling_data.cc b/cc/resources/layer_tiling_data.cc
index 0356985..6b33234 100644
--- a/cc/resources/layer_tiling_data.cc
+++ b/cc/resources/layer_tiling_data.cc
@@ -73,8 +73,8 @@ void LayerTilingData::ContentRectToTileIndices(gfx::Rect content_rect,
                                                int* bottom) const {
   // An empty rect doesn't result in an empty set of tiles, so don't pass an
   // empty rect.
-  // FIXME: Possibly we should fill a vector of tiles instead,
-  //        since the normal use of this function is to enumerate some tiles.
+  // TODO(enne): Possibly we should fill a vector of tiles instead, since the
+  // normal use of this function is to enumerate some tiles.
   DCHECK(!content_rect.IsEmpty());
 
   *left = tiling_data_.TileXIndexFromSrcCoord(content_rect.x());
diff --git a/cc/resources/prioritized_resource_manager.cc b/cc/resources/prioritized_resource_manager.cc
index 1a4bea3..591764b 100644
--- a/cc/resources/prioritized_resource_manager.cc
+++ b/cc/resources/prioritized_resource_manager.cc
@@ -188,10 +188,10 @@ void PrioritizedResourceManager::ClearPriorities() {
   DCHECK(proxy_->IsMainThread());
   for (TextureSet::iterator it = textures_.begin(); it != textures_.end();
        ++it) {
-    // FIXME: We should remove this and just set all priorities to
-    //        PriorityCalculator::lowestPriority() once we have priorities
-    //        for all textures (we can't currently calculate distances for
-    //        off-screen textures).
+    // TODO(reveman): We should remove this and just set all priorities to
+    // PriorityCalculator::lowestPriority() once we have priorities for all
+    // textures (we can't currently calculate distances for off-screen
+    // textures).
     (*it)->set_request_priority(
         PriorityCalculator::LingeringPriority((*it)->request_priority()));
   }
diff --git a/cc/resources/priority_calculator.cc b/cc/resources/priority_calculator.cc
index bb9908d..4e82820 100644
--- a/cc/resources/priority_calculator.cc
+++ b/cc/resources/priority_calculator.cc
@@ -62,9 +62,8 @@ int PriorityCalculator::RenderSurfacePriority() {
 
 // static
 int PriorityCalculator::LingeringPriority(int previous_priority) {
-  // FIXME: We should remove this once we have priorities for all
-  //        textures (we can't currently calculate distances for
-  //        off-screen textures).
+  // TODO(reveman): We should remove this once we have priorities for all
+  // textures (we can't currently calculate distances for off-screen textures).
   return std::min(kLingeringLimitPriority,
                   std::max(kLingeringBasePriority, previous_priority + 1));
 }
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index c3a6c7b..061bea8 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -748,7 +748,7 @@ void ResourceProvider::PrepareSendToParent(const ResourceIdArray& resources,
   list->clear();
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
-    // FIXME: Implement this path for software compositing.
+    // TODO(skaslev): Implement this path for software compositing.
     return;
   }
   bool need_sync_point = false;
@@ -781,7 +781,7 @@ void ResourceProvider::PrepareSendToChild(int child,
   list->clear();
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
-    // FIXME: Implement this path for software compositing.
+    // TODO(skaslev): Implement this path for software compositing.
     return;
   }
   Child& child_info = children_.find(child)->second;
@@ -818,7 +818,7 @@ void ResourceProvider::ReceiveFromChild(
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
-    // FIXME: Implement this path for software compositing.
+    // TODO(skaslev): Implement this path for software compositing.
     return;
   }
   Child& child_info = children_.find(child)->second;
@@ -855,7 +855,7 @@ void ResourceProvider::ReceiveFromParent(
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
-    // FIXME: Implement this path for software compositing.
+    // TODO(skaslev): Implement this path for software compositing.
     return;
   }
   for (TransferableResourceArray::const_iterator it = resources.begin();
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index d65ff20..1ac2983 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -809,11 +809,10 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
   // the entire child1 surface, but the damage tracker still needs the correct
   // logic to compute the exposed region on the root surface.
 
-  // FIXME: the expectations of this test case should change when we add
-  //        support for a unique scissor_rect per RenderSurface. In that case,
-  //        the child1 surface should be completely unchanged, since we are
-  //        only transforming it, while the root surface would be damaged
-  //        appropriately.
+  // TODO(shawnsingh): the expectations of this test case should change when we
+  // add support for a unique scissor_rect per RenderSurface. In that case, the
+  // child1 surface should be completely unchanged, since we are only
+  // transforming it, while the root surface would be damaged appropriately.
 
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
diff --git a/cc/trees/layer_sorter.cc b/cc/trees/layer_sorter.cc
index a313f9e..6729b19 100644
--- a/cc/trees/layer_sorter.cc
+++ b/cc/trees/layer_sorter.cc
@@ -227,7 +227,7 @@ LayerShape::LayerShape(float width,
       MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 1.f, 0.f), &clipped);
   gfx::Point3F c3 =
       MathUtil::MapPoint(draw_transform, gfx::Point3F(1.f, 0.f, 0.f), &clipped);
-  // FIXME: Deal with clipping.
+  // TODO(shawnsingh): Deal with clipping.
   gfx::Vector3dF c12 = c2 - c1;
   gfx::Vector3dF c13 = c3 - c1;
   layer_normal = gfx::CrossProduct(c13, c12);
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index f99a1ca..92cc90c 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -449,8 +449,9 @@ gfx::Transform ComputeSizeDeltaCompensation(
     result_transform.PreconcatTransform(
         container_layer_space_to_target_surface_space);
   } else {
-    // FIXME: A non-invertible matrix could still make meaningful projection.
-    // For example ScaleZ(0) is non-invertible but the layer is still visible.
+    // TODO(shawnsingh): A non-invertible matrix could still make meaningful
+    // projection.  For example ScaleZ(0) is non-invertible but the layer is
+    // still visible.
     return gfx::Transform();
   }
 
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index e19b4a8..6b6ea5d 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -86,7 +86,7 @@ static Region TransformSurfaceOpaqueRegion(const Region& region,
   bool clipped;
   gfx::QuadF transformed_bounds_quad =
       MathUtil::MapQuad(transform, gfx::QuadF(region.bounds()), &clipped);
-  // FIXME: Find a rect interior to each transformed quad.
+  // TODO(danakj): Find a rect interior to each transformed quad.
   if (clipped || !transformed_bounds_quad.IsRectilinear())
     return Region();
 
@@ -425,7 +425,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::
   bool clipped;
   gfx::QuadF visible_transformed_quad = MathUtil::MapQuad(
       layer->draw_transform(), gfx::QuadF(opaque_contents.bounds()), &clipped);
-  // FIXME: Find a rect interior to each transformed quad.
+  // TODO(danakj): Find a rect interior to each transformed quad.
   if (clipped || !visible_transformed_quad.IsRectilinear())
     return;
 
diff --git a/cc/trees/quad_culler.cc b/cc/trees/quad_culler.cc
index 1609d18..760c79d 100644
--- a/cc/trees/quad_culler.cc
+++ b/cc/trees/quad_culler.cc
@@ -33,8 +33,8 @@ QuadCuller::QuadCuller(QuadList* quad_list,
 
 SharedQuadState* QuadCuller::UseSharedQuadState(
     scoped_ptr<SharedQuadState> shared_quad_state) {
-  // FIXME: If all quads are culled for the shared_quad_state, we can drop it
-  // from the list.
+  // TODO(danakj): If all quads are culled for the shared_quad_state, we can
+  // drop it from the list.
   current_shared_quad_state_ = shared_quad_state.get();
   shared_quad_state_list_->push_back(shared_quad_state.Pass());
   return current_shared_quad_state_;
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 92b7b68..484acb6 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -266,8 +266,9 @@ void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
 }
 
 void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) {
-  // FIXME: Once we move render_widget scheduling into this class, we can
-  // treat redraw requests more efficiently than CommitAndRedraw requests.
+  // TODO(brianderson): Once we move render_widget scheduling into this class,
+  // we can treat redraw requests more efficiently than CommitAndRedraw
+  // requests.
   layer_tree_host_impl_->SetViewportDamage(damage_rect);
   SetNeedsCommit();
 }