cc: Fix capitalization style in chromified files.

Style-only change.

Many already-chromified files missed a variable or function name
here and there. This grabs (hopefully) all of them.

For the record, I found these with:
git gs '[^a-zA-Z0-9_>\."][a-jl-z]\+[A-Z][A-Za-z0-9_]*\($\|[ !=;,\.^&*)"]\)'

R=enne
BUG=

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

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

115 files changed, 828 insertions, 819 deletions

diff --git a/cc/animation/animation.cc b/cc/animation/animation.cc
index d81713b..e0e7e7c 100644
--- a/cc/animation/animation.cc
+++ b/cc/animation/animation.cc
@@ -82,9 +82,9 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
   if (suspended_)
     return;
 
-  char nameBuffer[256];
-  base::snprintf(nameBuffer,
-                 sizeof(nameBuffer),
+  char name_buffer[256];
+  base::snprintf(name_buffer,
+                 sizeof(name_buffer),
                  "%s-%d%s",
                  s_targetPropertyNames[target_property_],
                  group_,
@@ -97,7 +97,7 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
 
   if (is_waiting_to_start && run_state == Running) {
     TRACE_EVENT_ASYNC_BEGIN1(
-        "cc", "Animation", this, "Name", TRACE_STR_COPY(nameBuffer));
+        "cc", "Animation", this, "Name", TRACE_STR_COPY(name_buffer));
   }
 
   bool was_finished = is_finished();
@@ -115,19 +115,19 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
   if (!was_finished && is_finished())
     TRACE_EVENT_ASYNC_END0("cc", "Animation", this);
 
-  char stateBuffer[256];
-  base::snprintf(stateBuffer,
-                 sizeof(stateBuffer),
+  char state_buffer[256];
+  base::snprintf(state_buffer,
+                 sizeof(state_buffer),
                  "%s->%s",
                  old_run_state_name,
                  new_run_state_name);
 
   TRACE_EVENT_INSTANT2("cc",
-                       "LayerAnimationController::setRunState",
+                       "LayerAnimationController::SetRunState",
                        "Name",
-                       TRACE_STR_COPY(nameBuffer),
+                       TRACE_STR_COPY(name_buffer),
                        "State",
-                       TRACE_STR_COPY(stateBuffer));
+                       TRACE_STR_COPY(state_buffer));
 }
 
 void Animation::Suspend(double monotonic_time) {
diff --git a/cc/animation/animation.h b/cc/animation/animation.h
index f1692ad..6a0f772 100644
--- a/cc/animation/animation.h
+++ b/cc/animation/animation.h
@@ -80,7 +80,7 @@ class CC_EXPORT Animation {
   void Suspend(double monotonic_time);
   void Resume(double monotonic_time);
 
-  // If alternatesDirection is true, on odd numbered iterations we reverse the
+  // If alternates_direction is true, on odd numbered iterations we reverse the
   // curve.
   bool alternates_direction() const { return alternates_direction_; }
   void set_alternates_direction(bool alternates) {
@@ -164,7 +164,7 @@ class CC_EXPORT Animation {
   // purposes.
   bool suspended_;
 
-  // These are used in trimTimeToCurrentIteration to account for time
+  // These are used in TrimTimeToCurrentIteration to account for time
   // spent while paused. This is not included in AnimationState since it
   // there is absolutely no need for clients of this controller to know
   // about these values.
diff --git a/cc/animation/layer_animation_controller.cc b/cc/animation/layer_animation_controller.cc
index ef280d6..5f7ad26 100644
--- a/cc/animation/layer_animation_controller.cc
+++ b/cc/animation/layer_animation_controller.cc
@@ -97,7 +97,7 @@ void LayerAnimationController::SuspendAnimations(double monotonic_time) {
 }
 
 // Looking at GraphicsLayerCA, this appears to be the analog to
-// suspendAnimations, which is for testing.
+// SuspendAnimations, which is for testing.
 void LayerAnimationController::ResumeAnimations(double monotonic_time) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->run_state() == Animation::Paused)
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index 48ce28b..4907de7 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -205,7 +205,7 @@ TEST(LayerAnimationControllerTest, TrivialTransition) {
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  // A non-implOnly animation should not generate property updates.
+  // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
   controller->Animate(1.0);
@@ -852,7 +852,7 @@ TEST(LayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) {
             active_animation->run_state());
 }
 
-// Tests that skipping a call to updateState works as expected.
+// Tests that skipping a call to UpdateState works as expected.
 TEST(LayerAnimationControllerTest, SkipUpdateState) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
@@ -874,7 +874,7 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
       2,
       Animation::Opacity));
 
-  // Animate but don't updateState.
+  // Animate but don't UpdateState.
   controller->Animate(1.0);
 
   controller->Animate(2.0);
diff --git a/cc/base/hash_pair.h b/cc/base/hash_pair.h
index 6b6918d..e8602d2 100644
--- a/cc/base/hash_pair.h
+++ b/cc/base/hash_pair.h
@@ -40,7 +40,7 @@ namespace BASE_HASH_NAMESPACE {
 // Theorem 4.3.3 of the thesis "Über die Komplexität der Multiplikation in
 // eingeschränkten Branchingprogrammmodellen" by Woelfel, is:
 //
-//   h32(x32, y32) = (h64(x32, y32) * randOdd64 + rand16 * 2^16) % 2^64 / 2^32
+//   h32(x32, y32) = (h64(x32, y32) * rand_odd64 + rand16 * 2^16) % 2^64 / 2^32
 
 #define DEFINE_32BIT_PAIR_HASH(type1, type2) \
     DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) { \
@@ -51,13 +51,13 @@ namespace BASE_HASH_NAMESPACE {
       if (sizeof(std::size_t) >= sizeof(uint64)) \
         return static_cast<std::size_t>(hash64); \
       \
-      uint64 oddRandom = 481046412LL << 32 | 1025306954LL; \
-      uint32 shiftRandom = 10121U << 16; \
+      uint64 odd_random = 481046412LL << 32 | 1025306954LL; \
+      uint32 shift_random = 10121U << 16; \
       \
-      hash64 = hash64 * oddRandom + shiftRandom; \
-      std::size_t highBits = static_cast<std::size_t>( \
+      hash64 = hash64 * odd_random + shift_random; \
+      std::size_t high_bits = static_cast<std::size_t>( \
           hash64 >> (sizeof(uint64) - sizeof(std::size_t))); \
-      return highBits; \
+      return high_bits; \
     } \
   DEFINE_PAIR_HASH_FUNCTION_END();
 
@@ -88,10 +88,10 @@ DEFINE_32BIT_PAIR_HASH(unsigned, unsigned);
 
 #define DEFINE_64BIT_PAIR_HASH(type1, type2) \
     DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) { \
-      uint32 shortRandom1 = 842304669U; \
-      uint32 shortRandom2 = 619063811U; \
-      uint32 shortRandom3 = 937041849U; \
-      uint32 shortRandom4 = 3309708029U; \
+      uint32 short_random1 = 842304669U; \
+      uint32 short_random2 = 619063811U; \
+      uint32 short_random3 = 937041849U; \
+      uint32 short_random4 = 3309708029U; \
       \
       uint64 value1 = value.first; \
       uint64 value2 = value.second; \
@@ -100,23 +100,23 @@ DEFINE_32BIT_PAIR_HASH(unsigned, unsigned);
       uint32 value2a = static_cast<uint32>(value2 & 0xffffffff); \
       uint32 value2b = static_cast<uint32>((value2 >> 32) & 0xffffffff); \
       \
-      uint64 product1 = static_cast<uint64>(value1a) * shortRandom1; \
-      uint64 product2 = static_cast<uint64>(value1b) * shortRandom2; \
-      uint64 product3 = static_cast<uint64>(value2a) * shortRandom3; \
-      uint64 product4 = static_cast<uint64>(value2b) * shortRandom4; \
+      uint64 product1 = static_cast<uint64>(value1a) * short_random1; \
+      uint64 product2 = static_cast<uint64>(value1b) * short_random2; \
+      uint64 product3 = static_cast<uint64>(value2a) * short_random3; \
+      uint64 product4 = static_cast<uint64>(value2b) * short_random4; \
       \
       uint64 hash64 = product1 + product2 + product3 + product4; \
       \
       if (sizeof(std::size_t) >= sizeof(uint64)) \
         return static_cast<std::size_t>(hash64); \
       \
-      uint64 oddRandom = 1578233944LL << 32 | 194370989LL; \
-      uint32 shiftRandom = 20591U << 16; \
+      uint64 odd_random = 1578233944LL << 32 | 194370989LL; \
+      uint32 shift_random = 20591U << 16; \
       \
-      hash64 = hash64 * oddRandom + shiftRandom; \
-      std::size_t highBits = static_cast<std::size_t>( \
+      hash64 = hash64 * odd_random + shift_random; \
+      std::size_t high_bits = static_cast<std::size_t>( \
           hash64 >> (sizeof(uint64) - sizeof(std::size_t))); \
-      return highBits; \
+      return high_bits; \
     } \
   DEFINE_PAIR_HASH_FUNCTION_END();
 
diff --git a/cc/base/math_util.h b/cc/base/math_util.h
index dea3b08..dc9110f 100644
--- a/cc/base/math_util.h
+++ b/cc/base/math_util.h
@@ -80,7 +80,7 @@ class CC_EXPORT MathUtil {
   }
 
   // Background: Existing transform code does not do the right thing in
-  // mapRect / mapQuad / projectQuad when there is a perspective projection that
+  // MapRect / MapQuad / ProjectQuad when there is a perspective projection that
   // causes one of the transformed vertices to go to w < 0. In those cases, it
   // is necessary to perform clipping in homogeneous coordinates, after applying
   // the transform, before dividing-by-w to convert to cartesian coordinates.
@@ -95,14 +95,14 @@ class CC_EXPORT MathUtil {
                                        const gfx::RectF& rect);
 
   // Returns an array of vertices that represent the clipped polygon. After
-  // returning, indexes from 0 to numVerticesInClippedQuad are valid in the
-  // clippedQuad array. Note that numVerticesInClippedQuad may be zero, which
-  // means the entire quad was clipped, and none of the vertices in the array
-  // are valid.
+  // returning, indexes from 0 to num_vertices_in_clipped_quad are valid in the
+  // clipped_quad array. Note that num_vertices_in_clipped_quad may be zero,
+  // which means the entire quad was clipped, and none of the vertices in the
+  // array are valid.
   static void MapClippedQuad(const gfx::Transform& transform,
                              const gfx::QuadF& src_quad,
-                             gfx::PointF clippedQuad[8],
-                             int& numVerticesInClippedQuad);
+                             gfx::PointF clipped_quad[8],
+                             int& num_vertices_in_clipped_quad);
 
   static gfx::RectF ComputeEnclosingRectOfVertices(gfx::PointF vertices[],
                                                    int num_vertices);
diff --git a/cc/base/region_unittest.cc b/cc/base/region_unittest.cc
index eaf8d74..737ae27 100644
--- a/cc/base/region_unittest.cc
+++ b/cc/base/region_unittest.cc
@@ -238,25 +238,25 @@ TEST(RegionTest, ContainsRegion) {
   TEST_NO_CONTAINS(gfx::Rect(10, 10, 1, 1), gfx::Rect(10, 10, 2, 2));
   TEST_NO_CONTAINS(gfx::Rect(10, 10, 1, 1), gfx::Rect(9, 9, 3, 3));
 
-  Region hLines;
+  Region h_lines;
   for (int i = 10; i < 20; i += 2)
-    hLines.Union(gfx::Rect(i, 10, 1, 10));
+    h_lines.Union(gfx::Rect(i, 10, 1, 10));
 
-  TEST_CONTAINS(gfx::Rect(10, 10, 9, 10), hLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 10, 9, 9), hLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 11, 9, 9), hLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 10, 8, 10), hLines);
-  TEST_NO_CONTAINS(gfx::Rect(11, 10, 8, 10), hLines);
+  TEST_CONTAINS(gfx::Rect(10, 10, 9, 10), h_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 10, 9, 9), h_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 11, 9, 9), h_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 10, 8, 10), h_lines);
+  TEST_NO_CONTAINS(gfx::Rect(11, 10, 8, 10), h_lines);
 
-  Region vLines;
+  Region v_lines;
   for (int i = 10; i < 20; i += 2)
-    vLines.Union(gfx::Rect(10, i, 10, 1));
+    v_lines.Union(gfx::Rect(10, i, 10, 1));
 
-  TEST_CONTAINS(gfx::Rect(10, 10, 10, 9), vLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 10, 9, 9), vLines);
-  TEST_NO_CONTAINS(gfx::Rect(11, 10, 9, 9), vLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 10, 10, 8), vLines);
-  TEST_NO_CONTAINS(gfx::Rect(10, 11, 10, 8), vLines);
+  TEST_CONTAINS(gfx::Rect(10, 10, 10, 9), v_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 10, 9, 9), v_lines);
+  TEST_NO_CONTAINS(gfx::Rect(11, 10, 9, 9), v_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 10, 10, 8), v_lines);
+  TEST_NO_CONTAINS(gfx::Rect(10, 11, 10, 8), v_lines);
 
   Region grid;
   for (int i = 10; i < 20; i += 2)
@@ -269,21 +269,21 @@ TEST(RegionTest, ContainsRegion) {
   TEST_NO_CONTAINS(gfx::Rect(10, 10, 8, 9), grid);
   TEST_NO_CONTAINS(gfx::Rect(11, 10, 8, 9), grid);
 
-  TEST_CONTAINS(hLines, hLines);
-  TEST_CONTAINS(vLines, vLines);
-  TEST_NO_CONTAINS(vLines, hLines);
-  TEST_NO_CONTAINS(hLines, vLines);
+  TEST_CONTAINS(h_lines, h_lines);
+  TEST_CONTAINS(v_lines, v_lines);
+  TEST_NO_CONTAINS(v_lines, h_lines);
+  TEST_NO_CONTAINS(h_lines, v_lines);
   TEST_CONTAINS(grid, grid);
-  TEST_CONTAINS(hLines, grid);
-  TEST_CONTAINS(vLines, grid);
-  TEST_NO_CONTAINS(grid, hLines);
-  TEST_NO_CONTAINS(grid, vLines);
+  TEST_CONTAINS(h_lines, grid);
+  TEST_CONTAINS(v_lines, grid);
+  TEST_NO_CONTAINS(grid, h_lines);
+  TEST_NO_CONTAINS(grid, v_lines);
 
   for (int i = 10; i < 20; i += 2)
-    TEST_CONTAINS(hLines, gfx::Rect(i, 10, 1, 10));
+    TEST_CONTAINS(h_lines, gfx::Rect(i, 10, 1, 10));
 
   for (int i = 10; i < 20; i += 2)
-    TEST_CONTAINS(vLines, gfx::Rect(10, i, 10, 1));
+    TEST_CONTAINS(v_lines, gfx::Rect(10, i, 10, 1));
 
   for (int i = 10; i < 20; i += 2)
     for (int j = 10; j < 20; j += 2)
diff --git a/cc/base/scoped_ptr_hash_map.h b/cc/base/scoped_ptr_hash_map.h
index a2a8be7..734fb8a 100644
--- a/cc/base/scoped_ptr_hash_map.h
+++ b/cc/base/scoped_ptr_hash_map.h
@@ -42,14 +42,14 @@ class ScopedPtrHashMap {
     iterator it = find(key);
     if (it != end())
       erase(it);
-    Value* rawPtr = data.release();
-    return data_.insert(std::pair<Key, Value*>(key, rawPtr));
+    Value* raw_ptr = data.release();
+    return data_.insert(std::pair<Key, Value*>(key, raw_ptr));
   }
 
   // Does nothing if key is already present
   std::pair<iterator, bool> add(Key key, scoped_ptr<Value> data) {
-    Value* rawPtr = data.release();
-    return data_.insert(std::pair<Key, Value*>(key, rawPtr));
+    Value* raw_ptr = data.release();
+    return data_.insert(std::pair<Key, Value*>(key, raw_ptr));
   }
 
   void erase(iterator it) {
diff --git a/cc/base/tiling_data.cc b/cc/base/tiling_data.cc
index 57985c1..f734b35 100644
--- a/cc/base/tiling_data.cc
+++ b/cc/base/tiling_data.cc
@@ -11,11 +11,15 @@
 
 namespace cc {
 
-static int ComputeNumTiles(int max_texture_size, int total_size, int border_texels) {
+static int ComputeNumTiles(int max_texture_size,
+                           int total_size,
+                           int border_texels) {
   if (max_texture_size - 2 * border_texels <= 0)
     return total_size > 0 && max_texture_size >= total_size ? 1 : 0;
 
-  int num_tiles = std::max(1, 1 + (total_size - 1 - 2 * border_texels) / (max_texture_size - 2 * border_texels));
+  int num_tiles = std::max(1,
+                           1 + (total_size - 1 - 2 * border_texels) /
+                           (max_texture_size - 2 * border_texels));
   return total_size > 0 ? num_tiles : 0;
 }
 
@@ -27,10 +31,10 @@ TilingData::TilingData()
 TilingData::TilingData(
     gfx::Size max_texture_size,
     gfx::Size total_size,
-    bool hasBorderTexels)
+    bool has_border_texels)
     : max_texture_size_(max_texture_size),
       total_size_(total_size),
-      border_texels_(hasBorderTexels ? 1 : 0) {
+      border_texels_(has_border_texels ? 1 : 0) {
   RecomputeNumTiles();
 }
 
diff --git a/cc/debug/fake_web_graphics_context_3d.cc b/cc/debug/fake_web_graphics_context_3d.cc
index 0f53255..c626eb1 100644
--- a/cc/debug/fake_web_graphics_context_3d.cc
+++ b/cc/debug/fake_web_graphics_context_3d.cc
@@ -41,7 +41,7 @@ bool FakeWebGraphicsContext3D::isGLES2Compliant() {
 
 bool FakeWebGraphicsContext3D::readBackFramebuffer(
     unsigned char* pixels,
-    size_t bufferSize,
+    size_t buffer_size,
     WebGLId framebuffer,
     int width,
     int height) {
diff --git a/cc/debug/fake_web_graphics_context_3d.h b/cc/debug/fake_web_graphics_context_3d.h
index 19ed9a7..dc0ea99 100644
--- a/cc/debug/fake_web_graphics_context_3d.h
+++ b/cc/debug/fake_web_graphics_context_3d.h
@@ -80,10 +80,14 @@ class CC_EXPORT FakeWebGraphicsContext3D :
   virtual void requestExtensionCHROMIUM(const char*) {}
 
   virtual void blitFramebufferCHROMIUM(
-      WebKit::WGC3Dint srcX0, WebKit::WGC3Dint srcY0,
-      WebKit::WGC3Dint srcX1, WebKit::WGC3Dint srcY1,
-      WebKit::WGC3Dint dstX0, WebKit::WGC3Dint dstY0,
-      WebKit::WGC3Dint dstX1, WebKit::WGC3Dint dstY1,
+      WebKit::WGC3Dint src_x0,
+      WebKit::WGC3Dint src_y0,
+      WebKit::WGC3Dint src_x1,
+      WebKit::WGC3Dint src_y1,
+      WebKit::WGC3Dint dst_x0,
+      WebKit::WGC3Dint dst_y0,
+      WebKit::WGC3Dint dst_x1,
+      WebKit::WGC3Dint dst_y1,
       WebKit::WGC3Dbitfield mask,
       WebKit::WGC3Denum filter) {}
   virtual void renderbufferStorageMultisampleCHROMIUM(
@@ -160,7 +164,7 @@ class CC_EXPORT FakeWebGraphicsContext3D :
       WebKit::WGC3Dsizei width,
       WebKit::WGC3Dsizei height,
       WebKit::WGC3Dint border,
-      WebKit::WGC3Dsizei imageSize,
+      WebKit::WGC3Dsizei image_size,
       const void* data) {}
   virtual void compressedTexSubImage2D(
       WebKit::WGC3Denum target,
@@ -170,7 +174,7 @@ class CC_EXPORT FakeWebGraphicsContext3D :
       WebKit::WGC3Dsizei width,
       WebKit::WGC3Dsizei height,
       WebKit::WGC3Denum format,
-      WebKit::WGC3Dsizei imageSize,
+      WebKit::WGC3Dsizei image_size,
       const void* data) {}
   virtual void copyTexImage2D(
       WebKit::WGC3Denum target,
@@ -194,8 +198,8 @@ class CC_EXPORT FakeWebGraphicsContext3D :
   virtual void depthFunc(WebKit::WGC3Denum func) {}
   virtual void depthMask(WebKit::WGC3Dboolean flag) {}
   virtual void depthRange(
-      WebKit::WGC3Dclampf zNear,
-      WebKit::WGC3Dclampf zFar) {}
+      WebKit::WGC3Dclampf z_near,
+      WebKit::WGC3Dclampf z_far) {}
   virtual void detachShader(WebKit::WebGLId program, WebKit::WebGLId shader) {}
   virtual void disable(WebKit::WGC3Denum cap) {}
   virtual void disableVertexAttribArray(WebKit::WGC3Duint index) {}
@@ -236,7 +240,7 @@ class CC_EXPORT FakeWebGraphicsContext3D :
       ActiveInfo&);
   virtual void getAttachedShaders(
       WebKit::WebGLId program,
-      WebKit::WGC3Dsizei maxCount,
+      WebKit::WGC3Dsizei max_count,
       WebKit::WGC3Dsizei* count,
       WebKit::WebGLId* shaders) {}
   virtual WebKit::WGC3Dint getAttribLocation(
diff --git a/cc/debug/frame_rate_counter.cc b/cc/debug/frame_rate_counter.cc
index d546b10..bcd31b0 100644
--- a/cc/debug/frame_rate_counter.cc
+++ b/cc/debug/frame_rate_counter.cc
@@ -111,7 +111,7 @@ double FrameRateCounter::GetAverageFPS() const {
   // the first few swapbuffers happen instantly which skews the statistics
   // too much for short lived animations.
   //
-  // isBadFrameInterval encapsulates the frame too slow/frame too fast logic.
+  // IsBadFrameInterval encapsulates the frame too slow/frame too fast logic.
 
   for (RingBufferType::Iterator it = --ring_buffer_.End();
        it && frame_times_total < 1.0;
diff --git a/cc/debug/overdraw_metrics.cc b/cc/debug/overdraw_metrics.cc
index 0afaa44..b8a382c 100644
--- a/cc/debug/overdraw_metrics.cc
+++ b/cc/debug/overdraw_metrics.cc
@@ -46,13 +46,13 @@ static inline float PolygonArea(gfx::PointF points[8], int num_points) {
 // of the resulting polygon.
 static inline float AreaOfMappedQuad(const gfx::Transform& transform,
                                      const gfx::QuadF& quad) {
-  gfx::PointF clippedQuad[8];
+  gfx::PointF clipped_quad[8];
   int num_vertices_in_clipped_quad = 0;
   MathUtil::MapClippedQuad(transform,
                            quad,
-                           clippedQuad,
+                           clipped_quad,
                            num_vertices_in_clipped_quad);
-  return PolygonArea(clippedQuad, num_vertices_in_clipped_quad);
+  return PolygonArea(clipped_quad, num_vertices_in_clipped_quad);
 }
 
 void OverdrawMetrics::DidPaint(gfx::Rect painted_rect) {
diff --git a/cc/debug/rendering_stats.h b/cc/debug/rendering_stats.h
index 33ea2c6..675af68 100644
--- a/cc/debug/rendering_stats.h
+++ b/cc/debug/rendering_stats.h
@@ -36,7 +36,7 @@ struct CC_EXPORT RenderingStats {
 
   RenderingStats();
 
-  // In conjunction with enumerateFields, this allows the embedder to
+  // In conjunction with EnumerateFields, this allows the embedder to
   // enumerate the values in this structure without
   // having to embed references to its specific member variables. This
   // simplifies the addition of new fields to this type.
diff --git a/cc/input/input_handler.h b/cc/input/input_handler.h
index 7be60a1..cf18a66 100644
--- a/cc/input/input_handler.h
+++ b/cc/input/input_handler.h
@@ -41,7 +41,7 @@ class CC_EXPORT InputHandlerClient {
                                    ScrollInputType type) = 0;
 
   // Scroll the selected layer starting at the given position. If the scroll
-  // type given to scrollBegin was a gesture, then the scroll point and delta
+  // type given to ScrollBegin was a gesture, then the scroll point and delta
   // should be in viewport (logical pixel) coordinates. Otherwise they are in
   // scrolling layer's (logical pixel) space. If there is no room to move the
   // layer in the requested direction, its first ancestor layer that can be
diff --git a/cc/input/top_controls_manager_unittest.cc b/cc/input/top_controls_manager_unittest.cc
index dbe174f..6ff002b 100644
--- a/cc/input/top_controls_manager_unittest.cc
+++ b/cc/input/top_controls_manager_unittest.cc
@@ -73,7 +73,7 @@ class MockTopControlsManagerClient : public TopControlsManagerClient {
   float top_controls_hide_threshold_;
 };
 
-TEST(TopControlsManagerTest, ensureScrollThresholdApplied) {
+TEST(TopControlsManagerTest, EnsureScrollThresholdApplied) {
   MockTopControlsManagerClient client(0.5f, 0.5f);
   TopControlsManager* manager = client.manager();
 
@@ -117,7 +117,7 @@ TEST(TopControlsManagerTest, ensureScrollThresholdApplied) {
   manager->ScrollEnd();
 }
 
-TEST(TopControlsManagerTest, partialShownHideAnimation) {
+TEST(TopControlsManagerTest, PartialShownHideAnimation) {
   MockTopControlsManagerClient client(0.5f, 0.5f);
   TopControlsManager* manager = client.manager();
   manager->ScrollBegin();
@@ -147,7 +147,7 @@ TEST(TopControlsManagerTest, partialShownHideAnimation) {
   EXPECT_EQ(0.f, manager->content_top_offset());
 }
 
-TEST(TopControlsManagerTest, partialShownShowAnimation) {
+TEST(TopControlsManagerTest, PartialShownShowAnimation) {
   MockTopControlsManagerClient client(0.5f, 0.5f);
   TopControlsManager* manager = client.manager();
   manager->ScrollBegin();
@@ -177,7 +177,7 @@ TEST(TopControlsManagerTest, partialShownShowAnimation) {
   EXPECT_EQ(100.f, manager->content_top_offset());
 }
 
-TEST(TopControlsManagerTest, partialHiddenWithAmbiguousThresholdShows) {
+TEST(TopControlsManagerTest, PartialHiddenWithAmbiguousThresholdShows) {
   MockTopControlsManagerClient client(0.25f, 0.25f);
   TopControlsManager* manager = client.manager();
 
@@ -203,7 +203,7 @@ TEST(TopControlsManagerTest, partialHiddenWithAmbiguousThresholdShows) {
   EXPECT_EQ(100.f, manager->content_top_offset());
 }
 
-TEST(TopControlsManagerTest, partialHiddenWithAmbiguousThresholdHides) {
+TEST(TopControlsManagerTest, PartialHiddenWithAmbiguousThresholdHides) {
   MockTopControlsManagerClient client(0.25f, 0.25f);
   TopControlsManager* manager = client.manager();
 
@@ -229,7 +229,7 @@ TEST(TopControlsManagerTest, partialHiddenWithAmbiguousThresholdHides) {
   EXPECT_EQ(0.f, manager->content_top_offset());
 }
 
-TEST(TopControlsManagerTest, partialShownWithAmbiguousThresholdHides) {
+TEST(TopControlsManagerTest, PartialShownWithAmbiguousThresholdHides) {
   MockTopControlsManagerClient client(0.25f, 0.25f);
   TopControlsManager* manager = client.manager();
 
@@ -259,7 +259,7 @@ TEST(TopControlsManagerTest, partialShownWithAmbiguousThresholdHides) {
   EXPECT_EQ(0.f, manager->content_top_offset());
 }
 
-TEST(TopControlsManagerTest, partialShownWithAmbiguousThresholdShows) {
+TEST(TopControlsManagerTest, PartialShownWithAmbiguousThresholdShows) {
   MockTopControlsManagerClient client(0.25f, 0.25f);
   TopControlsManager* manager = client.manager();
 
diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 2614b0c..8669f6f 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -159,8 +159,8 @@ void DelegatedRendererLayerImpl::ClearRenderPasses() {
 }
 
 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
-    LayerTreeImpl* treeImpl) {
-  return DelegatedRendererLayerImpl::Create(treeImpl, id()).PassAs<LayerImpl>();
+    LayerTreeImpl* tree_impl) {
+  return DelegatedRendererLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::DidLoseOutputSurface() {
@@ -197,8 +197,8 @@ RenderPass::Id DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
   base::hash_map<RenderPass::Id, int>::const_iterator found =
       render_passes_index_by_id_.find(delegated_render_pass_id);
   DCHECK(found != render_passes_index_by_id_.end());
-  unsigned delegatedRenderPassIndex = found->second;
-  return RenderPass::Id(id(), IndexToId(delegatedRenderPassIndex));
+  unsigned delegated_render_pass_index = found->second;
+  return RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
 }
 
 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
@@ -233,20 +233,20 @@ void DelegatedRendererLayerImpl::AppendQuads(
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
-  // If the index of the renderPassId is 0, then it is a renderPass generated
+  // If the index of the EenderPassId is 0, then it is a RenderPass generated
   // for a layer in this compositor, not the delegated renderer. Then we want to
-  // merge our root renderPass with the target renderPass. Otherwise, it is some
-  // renderPass which we added from the delegated renderer.
+  // merge our root RenderPass with the target RenderPass. Otherwise, it is some
+  // RenderPass which we added from the delegated renderer.
   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
   if (should_merge_root_render_pass_with_target) {
-    // Verify that the renderPass we are appending to is created our
-    // renderTarget.
+    // Verify that the RenderPass we are appending to is created our
+    // render_target.
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
     AppendRenderPassQuads(
         quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
   } else {
-    // Verify that the renderPass we are appending to was created by us.
+    // Verify that the RenderPass we are appending to was created by us.
     DCHECK(target_render_pass_id.layer_id == id());
 
     int render_pass_index = IdToIndex(target_render_pass_id.index);
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 8968996..5a21abc 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -93,25 +93,25 @@ class DelegatedRendererLayerImplTestSimple
     delegated_renderer_layer->SetTransform(transform);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
-    TestRenderPass* pass1 = addRenderPass(
+    TestRenderPass* pass1 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         gfx::Rect(6, 6, 6, 6),
         gfx::Transform());
-    addQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
-    TestRenderPass* pass2 = addRenderPass(
+    AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
+    TestRenderPass* pass2 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 7),
         gfx::Rect(7, 7, 7, 7),
         gfx::Transform());
-    addQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
-    addRenderPassQuad(pass2, pass1);
-    TestRenderPass* pass3 = addRenderPass(
+    AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
+    AddRenderPassQuad(pass2, pass1);
+    TestRenderPass* pass3 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 8),
         gfx::Rect(0, 0, 8, 8),
         gfx::Transform());
-    addRenderPassQuad(pass3, pass2);
+    AddRenderPassQuad(pass3, pass2);
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         &delegated_render_passes);
 
@@ -276,7 +276,7 @@ TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
-  // has no need to be a renderSurface for the quads it carries.
+  // has no need to be a RenderSurface for the quads it carries.
   EXPECT_FALSE(delegated_renderer_layer_->render_surface());
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
@@ -489,7 +489,7 @@ class DelegatedRendererLayerImplTestTransform
     bool child_pass_clipped = false;
 
     {
-      TestRenderPass* pass = addRenderPass(
+      TestRenderPass* pass = AddRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
@@ -524,7 +524,7 @@ class DelegatedRendererLayerImplTestTransform
     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
-    TestRenderPass* pass = addRenderPass(
+    TestRenderPass* pass = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
@@ -650,7 +650,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
       &contrib_delegated_shared_quad_state);
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer.
+  // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(21, 21, 60, 60).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
@@ -704,7 +704,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
       &contrib_delegated_shared_quad_state);
 
   // Since the quads have a clip_rect it should be modified by delegated
-  // renderer layer's drawTransform.
+  // renderer layer's draw_transform.
   // The position of the resulting clip_rect is:
   // (clip rect position (10) * scale to layer (30/50) + translate (8)) *
   //     layer scale (2) + layer position (20) = 48
@@ -886,7 +886,7 @@ class DelegatedRendererLayerImplTestClip
     bool child_pass_clipped = false;
 
     {
-      TestRenderPass* pass = addRenderPass(
+      TestRenderPass* pass = AddRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
@@ -919,7 +919,7 @@ class DelegatedRendererLayerImplTestClip
     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
-    TestRenderPass* pass = addRenderPass(
+    TestRenderPass* pass = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
@@ -1025,7 +1025,7 @@ TEST_F(DelegatedRendererLayerImplTestClip,
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer.
+  // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
@@ -1087,7 +1087,7 @@ TEST_F(DelegatedRendererLayerImplTestClip,
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer. When the layer
+  // the drawable_content_rect of the delegated renderer layer. When the layer
   // is clipped, that should be seen in the quads' clip_rect.
   EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
diff --git a/cc/layers/draw_properties.h b/cc/layers/draw_properties.h
index aba8c27..ad598bc 100644
--- a/cc/layers/draw_properties.h
+++ b/cc/layers/draw_properties.h
@@ -37,7 +37,7 @@ struct CC_EXPORT DrawProperties {
   gfx::Transform screen_space_transform;
 
   // DrawProperties::opacity may be different than LayerType::opacity,
-  // particularly in the case when a renderSurface re-parents the layer's
+  // particularly in the case when a RenderSurface re-parents the layer's
   // opacity, or when opacity is compounded by the hierarchy.
   float opacity;
 
@@ -53,7 +53,7 @@ struct CC_EXPORT DrawProperties {
   // True if the layer can use LCD text.
   bool can_use_lcd_text;
 
-  // True if the layer needs to be clipped by clipRect.
+  // True if the layer needs to be clipped by clip_rect.
   bool is_clipped;
 
   // The layer whose coordinate space this layer draws into. This can be
diff --git a/cc/layers/heads_up_display_layer.cc b/cc/layers/heads_up_display_layer.cc
index 51a6bcc..f2d46ed 100644
--- a/cc/layers/heads_up_display_layer.cc
+++ b/cc/layers/heads_up_display_layer.cc
@@ -56,8 +56,8 @@ void HeadsUpDisplayLayer::Update(ResourceUpdateQueue*,
 bool HeadsUpDisplayLayer::DrawsContent() const { return true; }
 
 scoped_ptr<LayerImpl> HeadsUpDisplayLayer::CreateLayerImpl(
-    LayerTreeImpl* treeImpl) {
-  return HeadsUpDisplayLayerImpl::Create(treeImpl, layer_id_).
+    LayerTreeImpl* tree_impl) {
+  return HeadsUpDisplayLayerImpl::Create(tree_impl, layer_id_).
       PassAs<LayerImpl>();
 }
 
diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index 566c899..929ff58 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc
@@ -85,7 +85,7 @@ void HeadsUpDisplayLayerImpl::WillDraw(ResourceProvider* resource_provider) {
   if (!hud_texture_)
     hud_texture_ = ScopedResource::create(resource_provider);
 
-  // TODO(danakj): Scale the HUD by deviceScale to make it more friendly under
+  // TODO(danakj): Scale the HUD by device scale to make it more friendly under
   // high DPI.
 
   // TODO(danakj): The HUD could swap between two textures instead of creating a
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 3bfc1de..d6a4ba3 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -83,7 +83,7 @@ void IOSurfaceLayerImpl::WillDraw(ResourceProvider* resource_provider) {
                                            io_surface_size_.height(),
                                            io_surface_id_,
                                            0);
-    // Do not check for error conditions. texImageIOSurface2DCHROMIUM is
+    // Do not check for error conditions. texImageIOSurface2DCHROMIUM() is
     // supposed to hold on to the last good IOSurface if the new one is already
     // closed. This is only a possibility during live resizing of plugins.
     // However, it seems that this is not sufficient to completely guard against
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index b07b308..105b4e4 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -311,10 +311,10 @@ void Layer::CalculateContentsScale(
     bool animating_transform_to_screen,
     float* contents_scale_x,
     float* contents_scale_y,
-    gfx::Size* contentBounds) {
+    gfx::Size* content_bounds) {
   *contents_scale_x = 1;
   *contents_scale_y = 1;
-  *contentBounds = bounds();
+  *content_bounds = bounds();
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
@@ -601,7 +601,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
-  // updateRect here. The LayerImpl's updateRect needs to accumulate (i.e.
+  // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->set_update_rect(update_rect_);
@@ -612,7 +612,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
         layer->layer_tree_impl()->FindActiveTreeLayerById(id());
     // Update the scroll delta from the active layer, which may have
     // adjusted its scroll delta prior to this pending layer being created.
-    // This code is identical to that in LayerImpl::setScrollDelta.
+    // This code is identical to that in LayerImpl::SetScrollDelta.
     if (active_twin) {
       DCHECK(layer->sent_scroll_delta().IsZero());
       layer->SetScrollDelta(active_twin->scroll_delta() -
@@ -702,7 +702,7 @@ void Layer::OnOpacityAnimated(float opacity) {
   // This is called due to an ongoing accelerated animation. Since this
   // animation is also being run on the impl thread, there is no need to request
   // a commit to push this value over, so set the value directly rather than
-  // calling setOpacity.
+  // calling SetOpacity.
   opacity_ = opacity;
 }
 
@@ -710,7 +710,7 @@ void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   // This is called due to an ongoing accelerated animation. Since this
   // animation is also being run on the impl thread, there is no need to request
   // a commit to push this value over, so set this value directly rather than
-  // calling setTransform.
+  // calling SetTransform.
   transform_ = transform;
 }
 
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index c0c34cc..2e72e63 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -279,9 +279,9 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
   void CreateRenderSurface();
 
-  // The contentsScale converts from logical, non-page-scaled pixels to target
-  // pixels. The contentsScale is 1 for the root layer as it is already in
-  // physical pixels. By default contentsScale is forced to be 1 except for
+  // The contents scale converts from logical, non-page-scaled pixels to target
+  // pixels. The contents scale is 1 for the root layer as it is already in
+  // physical pixels. By default contents scale is forced to be 1 except for
   // subclasses of ContentsScalingLayer.
   float contents_scale_x() const { return draw_properties_.contents_scale_x; }
   float contents_scale_y() const { return draw_properties_.contents_scale_y; }
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 1597d24..763a696 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -123,7 +123,7 @@ scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
 
 void LayerImpl::WillDraw(ResourceProvider* resource_provider) {
 #ifndef NDEBUG
-  // willDraw/didDraw must be matched.
+  // WillDraw/DidDraw must be matched.
   DCHECK(!between_will_draw_and_did_draw_);
   between_will_draw_and_did_draw_ = true;
 #endif
@@ -169,10 +169,10 @@ void LayerImpl::AppendDebugBorderQuad(
   GetDebugBorderProperties(&color, &width);
 
   gfx::Rect content_rect(content_bounds());
-  scoped_ptr<DebugBorderDrawQuad> debugBorderQuad =
+  scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
       DebugBorderDrawQuad::Create();
-  debugBorderQuad->SetNew(shared_quad_state, content_rect, color, width);
-  quad_sink->Append(debugBorderQuad.PassAs<DrawQuad>(), append_quads_data);
+  debug_border_quad->SetNew(shared_quad_state, content_rect, color, width);
+  quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
 }
 
 bool LayerImpl::HasDelegatedContent() const {
@@ -224,12 +224,12 @@ InputHandlerClient::ScrollStatus LayerImpl::TryScroll(
     gfx::PointF screen_space_point,
     InputHandlerClient::ScrollInputType type) const {
   if (should_scroll_on_main_thread()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed shouldScrollOnMainThread");
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
     return InputHandlerClient::ScrollOnMainThread;
   }
 
   if (!screen_space_transform().IsInvertible()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored nonInvertibleTransform");
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Ignored NonInvertibleTransform");
     return InputHandlerClient::ScrollIgnored;
   }
 
@@ -255,13 +255,13 @@ InputHandlerClient::ScrollStatus LayerImpl::TryScroll(
         non_fast_scrollable_region().Contains(
             gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
       TRACE_EVENT0("cc",
-                   "LayerImpl::tryScroll: Failed nonFastScrollableRegion");
+                   "LayerImpl::tryScroll: Failed NonFastScrollableRegion");
       return InputHandlerClient::ScrollOnMainThread;
     }
   }
 
   if (type == InputHandlerClient::Wheel && have_wheel_event_handlers()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed wheelEventHandlers");
+    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
     return InputHandlerClient::ScrollOnMainThread;
   }
 
@@ -349,7 +349,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
-  // updateRect here. The LayerImpl's updateRect needs to accumulate (i.e.
+  // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->set_update_rect(update_rect_);
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 8b09e2e..f33e644 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -94,10 +94,10 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   LayerTreeImpl* layer_tree_impl() const { return layer_tree_impl_; }
 
   scoped_ptr<SharedQuadState> CreateSharedQuadState() const;
-  // willDraw must be called before appendQuads. If willDraw is called,
-  // didDraw is guaranteed to be called before another willDraw or before
+  // WillDraw must be called before AppendQuads. If WillDraw is called,
+  // DidDraw is guaranteed to be called before another WillDraw or before
   // the layer is destroyed. To enforce this, any class that overrides
-  // willDraw/didDraw must call the base class version.
+  // WillDraw/DqidDraw must call the base class version.
   virtual void WillDraw(ResourceProvider* resource_provider);
   virtual void AppendQuads(QuadSink* quad_sink,
                            AppendQuadsData* append_quads_data) {}
@@ -189,7 +189,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   bool ShowDebugBorders() const;
 
   // These invalidate the host's render surface layer list.  The caller
-  // is responsible for calling setNeedsUpdateDrawProperties on the host
+  // is responsible for calling set_needs_update_draw_properties on the tree
   // so that its list can be recreated.
   void CreateRenderSurface();
   void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
@@ -245,8 +245,8 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
  return draw_properties_.render_surface.get();
   }
 
-  // The client should be responsible for setting bounds, contentBounds and
-  // contentsScale to appropriate values. LayerImpl doesn't calculate any of
+  // The client should be responsible for setting bounds, content bounds and
+  // contents scale to appropriate values. LayerImpl doesn't calculate any of
   // them from the other values.
 
   void SetBounds(gfx::Size bounds);
@@ -263,7 +263,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
                                       bool animating_transform_to_screen,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* contentBounds);
+                                      gfx::Size* content_bounds);
 
   void SetScrollOffset(gfx::Vector2d scroll_offset);
   gfx::Vector2d scroll_offset() const { return scroll_offset_; }
@@ -455,7 +455,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
 
   // Indicates that a property has changed on this layer that would not
   // affect the pixels on its target surface, but would require redrawing
-  // the targetSurface onto its ancestor targetSurface.
+  // the target_surface onto its ancestor target_surface.
   // For layers that do not own a surface this flag acts as
   // layer_property_changed_.
   bool layer_surface_property_changed_;
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index fb3bb28..cb65d76 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -155,7 +155,7 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   EXPECT_TRUE(child->LayerPropertyChanged());
   EXPECT_TRUE(grand_child->LayerPropertyChanged());
 
-  // Special case: check that setBounds changes behavior depending on
+  // Special case: check that SetBounds changes behavior depending on
   // masksToBounds.
   root->SetMasksToBounds(false);
   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246)));
diff --git a/cc/layers/layer_iterator.cc b/cc/layers/layer_iterator.cc
index 02634bd..5891168 100644
--- a/cc/layers/layer_iterator.cc
+++ b/cc/layers/layer_iterator.cc
@@ -44,7 +44,7 @@ void LayerIteratorActions::BackToFront::Next(
   // If the current layer has a RS, move to its layer list. Otherwise,
   // visit the next layer in the current RS layer list.
   if (it->current_layer_represents_contributing_render_surface()) {
-    // Save our position in the childLayer list for the RenderSurface,
+    // Save our position in the child_layers list for the RenderSurface,
     // then jump to the next RenderSurface. Save where we
     // came from in the next RenderSurface so we can get back to it.
     it->target_render_surface()->current_layer_index_history_ =
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index c0fa5d9..8a93c52 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -26,15 +26,15 @@ using ::testing::Mock;
 using ::testing::StrictMock;
 using ::testing::_;
 
-#define EXPECT_SET_NEEDS_COMMIT(expect, codeToTest) do {                \
+#define EXPECT_SET_NEEDS_COMMIT(expect, code_to_test) do {                \
     EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times((expect));   \
-    codeToTest;                                                         \
+    code_to_test;                                                         \
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());           \
   } while (false)
 
-#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, codeToTest) do {        \
+#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, code_to_test) do {        \
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
-    codeToTest;                                                         \
+    code_to_test;                                                         \
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());           \
   } while (false)
 
@@ -392,9 +392,9 @@ TEST_F(LayerTest, SetChildren) {
   scoped_refptr<Layer> child1 = Layer::Create();
   scoped_refptr<Layer> child2 = Layer::Create();
 
-  std::vector<scoped_refptr<Layer> > newChildren;
-  newChildren.push_back(child1);
-  newChildren.push_back(child2);
+  std::vector<scoped_refptr<Layer> > new_children;
+  new_children.push_back(child1);
+  new_children.push_back(child2);
 
   // Set up and verify initial test conditions: child1 has a parent, child2 has
   // no parent.
@@ -406,7 +406,7 @@ TEST_F(LayerTest, SetChildren) {
   new_parent->SetLayerTreeHost(layer_tree_host_.get());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
-      AtLeast(1), new_parent->SetChildren(newChildren));
+      AtLeast(1), new_parent->SetChildren(new_children));
 
   ASSERT_EQ(2U, new_parent->children().size());
   EXPECT_EQ(new_parent.get(), child1->parent());
@@ -471,7 +471,7 @@ TEST_F(LayerTest, GetRootLayerAfterTreeManipulations) {
 }
 
 TEST_F(LayerTest, CheckSetNeedsDisplayCausesCorrectBehavior) {
-  // The semantics for setNeedsDisplay which are tested here:
+  // The semantics for SetNeedsDisplay which are tested here:
   //   1. sets NeedsDisplay flag appropriately.
   //   2. indirectly calls SetNeedsCommit, exactly once for each call to
   //      SetNeedsDisplay.
@@ -566,7 +566,7 @@ TEST_F(LayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, test_layer->SetReplicaLayer(
       dummy_layer2.get()));
 
-  // The above tests should not have caused a change to the needsDisplay flag.
+  // The above tests should not have caused a change to the needs_display flag.
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
   // As layers are removed from the tree, they will cause a tree sync.
@@ -587,7 +587,7 @@ TEST_F(LayerTest, SetBoundsTriggersSetNeedsRedrawAfterGettingNonEmptyBounds) {
   test_layer->ResetNeedsDisplayForTesting();
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
-  // Calling setBounds only invalidates on the first time.
+  // Calling SetBounds only invalidates on the first time.
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(gfx::Size(7, 10)));
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 }
diff --git a/cc/layers/nine_patch_layer.cc b/cc/layers/nine_patch_layer.cc
index a4b4f70..4301a85 100644
--- a/cc/layers/nine_patch_layer.cc
+++ b/cc/layers/nine_patch_layer.cc
@@ -63,12 +63,12 @@ void NinePatchLayer::Update(ResourceUpdateQueue* queue,
 
   if (resource_ &&
       (bitmap_dirty_ || resource_->texture()->resource_id() == 0)) {
-    gfx::Rect contentRect(gfx::Point(),
-                          gfx::Size(bitmap_.width(), bitmap_.height()));
+    gfx::Rect content_rect(gfx::Point(),
+                           gfx::Size(bitmap_.width(), bitmap_.height()));
     ResourceUpdate upload = ResourceUpdate::Create(resource_->texture(),
                                                    &bitmap_,
-                                                   contentRect,
-                                                   contentRect,
+                                                   content_rect,
+                                                   content_rect,
                                                    gfx::Vector2d());
     queue->AppendFullUpload(upload);
     bitmap_dirty_ = false;
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index 53daedc..69432bf 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -102,16 +102,16 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   // Patch positions in layer space
   gfx::Rect top_left(0, 0, left_width, top_height);
-  gfx::Rect topRight(
+  gfx::Rect top_right(
       bounds().width() - right_width, 0, right_width, top_height);
-  gfx::Rect bottomLeft(
+  gfx::Rect bottom_left(
       0, bounds().height() - bottom_height, left_width, bottom_height);
-  gfx::Rect bottomRight(
-      topRight.x(), bottomLeft.y(), right_width, bottom_height);
+  gfx::Rect bottom_right(
+      top_right.x(), bottom_left.y(), right_width, bottom_height);
   gfx::Rect top(top_left.right(), 0, middle_width, top_height);
   gfx::Rect left(0, top_left.bottom(), left_width, middle_height);
-  gfx::Rect right(topRight.x(), topRight.bottom(), right_width, left.height());
-  gfx::Rect bottom(top.x(), bottomLeft.y(), top.width(), bottom_height);
+  gfx::Rect right(top_right.x(), top_right.bottom(), right_width, left.height());
+  gfx::Rect bottom(top.x(), bottom_left.y(), top.width(), bottom_height);
 
   float img_width = image_bounds_.width();
   float img_height = image_bounds_.height();
@@ -141,21 +141,21 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                                               bottom_height,
                                               img_width,
                                               img_height);
-  gfx::RectF uvTop(uv_top_left.right(),
+  gfx::RectF uv_top(uv_top_left.right(),
                    0,
                    (img_width - left_width - right_width) / img_width,
                    (top_height) / img_height);
-  gfx::RectF uvLeft(0,
+  gfx::RectF uv_left(0,
                     uv_top_left.bottom(),
                     left_width / img_width,
                     (img_height - top_height - bottom_height) / img_height);
-  gfx::RectF uvRight(uv_top_right.x(),
+  gfx::RectF uv_right(uv_top_right.x(),
                      uv_top_right.bottom(),
                      right_width / img_width,
-                     uvLeft.height());
-  gfx::RectF uvBottom(uvTop.x(),
+                     uv_left.height());
+  gfx::RectF uv_bottom(uv_top.x(),
                       uv_bottom_left.y(),
-                      uvTop.width(),
+                      uv_top.width(),
                       bottom_height / img_height);
 
   // Nothing is opaque here.
@@ -177,7 +177,7 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               topRight,
+               top_right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
@@ -188,7 +188,7 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               bottomLeft,
+               bottom_left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
@@ -200,7 +200,7 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               bottomRight,
+               bottom_right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
@@ -216,8 +216,8 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvTop.origin(),
-               uvTop.bottom_right(),
+               uv_top.origin(),
+               uv_top.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
@@ -228,8 +228,8 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvLeft.origin(),
-               uvLeft.bottom_right(),
+               uv_left.origin(),
+               uv_left.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
@@ -240,8 +240,8 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvRight.origin(),
-               uvRight.bottom_right(),
+               uv_right.origin(),
+               uv_right.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
@@ -252,8 +252,8 @@ void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvBottom.origin(),
-               uvBottom.bottom_right(),
+               uv_bottom.origin(),
+               uv_bottom.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
diff --git a/cc/layers/picture_image_layer_impl.cc b/cc/layers/picture_image_layer_impl.cc
index 9c478f0..9fa401f 100644
--- a/cc/layers/picture_image_layer_impl.cc
+++ b/cc/layers/picture_image_layer_impl.cc
@@ -9,8 +9,8 @@
 
 namespace cc {
 
-PictureImageLayerImpl::PictureImageLayerImpl(LayerTreeImpl* treeImpl, int id)
-    : PictureLayerImpl(treeImpl, id) {
+PictureImageLayerImpl::PictureImageLayerImpl(LayerTreeImpl* tree_impl, int id)
+    : PictureLayerImpl(tree_impl, id) {
 }
 
 PictureImageLayerImpl::~PictureImageLayerImpl() {
@@ -21,8 +21,8 @@ const char* PictureImageLayerImpl::LayerTypeAsString() const {
 }
 
 scoped_ptr<LayerImpl> PictureImageLayerImpl::CreateLayerImpl(
-    LayerTreeImpl* treeImpl) {
-  return PictureImageLayerImpl::Create(treeImpl, id()).PassAs<LayerImpl>();
+    LayerTreeImpl* tree_impl) {
+  return PictureImageLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void PictureImageLayerImpl::GetDebugBorderProperties(
diff --git a/cc/layers/picture_image_layer_impl.h b/cc/layers/picture_image_layer_impl.h
index 9c3f46d..4bbafa7f22 100644
--- a/cc/layers/picture_image_layer_impl.h
+++ b/cc/layers/picture_image_layer_impl.h
@@ -11,18 +11,18 @@ namespace cc {
 
 class CC_EXPORT PictureImageLayerImpl : public PictureLayerImpl {
  public:
-  static scoped_ptr<PictureImageLayerImpl> Create(LayerTreeImpl* treeImpl,
+  static scoped_ptr<PictureImageLayerImpl> Create(LayerTreeImpl* tree_impl,
                                                   int id) {
-    return make_scoped_ptr(new PictureImageLayerImpl(treeImpl, id));
+    return make_scoped_ptr(new PictureImageLayerImpl(tree_impl, id));
   }
   virtual ~PictureImageLayerImpl();
 
   virtual const char* LayerTypeAsString() const OVERRIDE;
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
-      LayerTreeImpl* treeImpl) OVERRIDE;
+      LayerTreeImpl* tree_impl) OVERRIDE;
 
  protected:
-  PictureImageLayerImpl(LayerTreeImpl* treeImpl, int id);
+  PictureImageLayerImpl(LayerTreeImpl* tree_impl, int id);
 
   virtual void CalculateRasterContentsScale(
       bool animating_transform_to_screen,
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 0e289d4..1225772 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -84,14 +84,14 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
 }
 
 
-void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
-                                   AppendQuadsData* appendQuadsData) {
+void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
+                                   AppendQuadsData* append_quads_data) {
   const gfx::Rect& rect = visible_content_rect();
   gfx::Rect content_rect(content_bounds());
 
-  SharedQuadState* sharedQuadState =
-      quadSink->UseSharedQuadState(CreateSharedQuadState());
-  AppendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
+  SharedQuadState* shared_quad_state =
+      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   bool clipped = false;
   gfx::QuadF target_quad = MathUtil::MapQuad(
@@ -131,11 +131,12 @@ void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
         width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
       }
 
-      scoped_ptr<DebugBorderDrawQuad> debugBorderQuad =
+      scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
           DebugBorderDrawQuad::Create();
       gfx::Rect geometry_rect = iter.geometry_rect();
-      debugBorderQuad->SetNew(sharedQuadState, geometry_rect, color, width);
-      quadSink->Append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
+      debug_border_quad->SetNew(shared_quad_state, geometry_rect, color, width);
+      quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(),
+                        append_quads_data);
     }
   }
 
@@ -156,17 +157,17 @@ void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
         // TODO(enne): Figure out how to show debug "invalidated checker" color
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
-        quad->SetNew(sharedQuadState, geometry_rect, color);
-        if (quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData))
-          appendQuadsData->numMissingTiles++;
+        quad->SetNew(shared_quad_state, geometry_rect, color);
+        if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
+          append_quads_data->numMissingTiles++;
       } else {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(sharedQuadState, geometry_rect, background_color());
-        if (quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData))
-          appendQuadsData->numMissingTiles++;
+        quad->SetNew(shared_quad_state, geometry_rect, background_color());
+        if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
+          append_quads_data->numMissingTiles++;
       }
 
-      appendQuadsData->hadIncompleteTile = true;
+      append_quads_data->hadIncompleteTile = true;
       continue;
     }
 
@@ -174,29 +175,29 @@ void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
     switch (drawing_info.mode()) {
       case ManagedTileState::DrawingInfo::TEXTURE_MODE: {
         if (iter->contents_scale() != ideal_contents_scale_)
-          appendQuadsData->hadIncompleteTile = true;
+          append_quads_data->hadIncompleteTile = true;
 
         gfx::RectF texture_rect = iter.texture_rect();
         gfx::Rect opaque_rect = iter->opaque_rect();
         opaque_rect.Intersect(content_rect);
 
         scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
-        quad->SetNew(sharedQuadState,
+        quad->SetNew(shared_quad_state,
                      geometry_rect,
                      opaque_rect,
                      drawing_info.get_resource_id(),
                      texture_rect,
                      iter.texture_size(),
                      drawing_info.contents_swizzled());
-        quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
       case ManagedTileState::DrawingInfo::SOLID_COLOR_MODE: {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(sharedQuadState,
+        quad->SetNew(shared_quad_state,
                      geometry_rect,
                      drawing_info.get_solid_color());
-        quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
       case ManagedTileState::DrawingInfo::TRANSPARENT_MODE:
@@ -213,7 +214,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
-  // better scheme would be to maintain a tighter visibleContentRect for the
+  // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
 }
@@ -379,7 +380,7 @@ gfx::Size PictureLayerImpl::CalculateTileSize(
     // of different textures sizes to help recycling, and also keeps all
     // textures multiple-of-eight, which is preferred on some drivers (IMG).
     bool avoid_pow2 =
-        layer_tree_impl()->rendererCapabilities().avoid_pow2_textures;
+        layer_tree_impl()->GetRendererCapabilities().avoid_pow2_textures;
     int round_up_to = avoid_pow2 ? 56 : 64;
     width = RoundUp(width, round_up_to);
     height = RoundUp(height, round_up_to);
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 7a7e98e..063b632 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -138,7 +138,7 @@ class MockCanvas : public SkCanvas {
   explicit MockCanvas(SkDevice* device) : SkCanvas(device) {}
 
   virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
-    // Capture calls before SkCanvas quickReject kicks in
+    // Capture calls before SkCanvas quickReject() kicks in.
     rects_.push_back(rect);
   }
 
@@ -254,13 +254,13 @@ class PictureLayerImplTest : public testing::Test {
     SkBitmap store;
     store.setConfig(SkBitmap::kNo_Config, 1000, 1000);
     SkDevice device(store);
-    int64 pixelsRasterized;
+    int64 pixels_rasterized;
 
     std::vector<SkRect>::const_iterator rect_iter = rects.begin();
     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
       MockCanvas mock_canvas(&device);
       active_pile->Raster(&mock_canvas, (*tile_iter)->content_rect(),
-          1.0f, &pixelsRasterized);
+          1.0f, &pixels_rasterized);
 
       // This test verifies that when drawing the contents of a specific tile
       // at content scale 1.0, the playback canvas never receives content from
@@ -283,17 +283,17 @@ class PictureLayerImplTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
-TEST_F(PictureLayerImplTest, tileGridAlignment) {
+TEST_F(PictureLayerImplTest, TileGridAlignment) {
   host_impl_.SetDeviceScaleFactor(1.f);
   TestTileGridAlignmentCommon();
 }
 
-TEST_F(PictureLayerImplTest, tileGridAlignmentHiDPI) {
+TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
   host_impl_.SetDeviceScaleFactor(2.f);
   TestTileGridAlignmentCommon();
 }
 
-TEST_F(PictureLayerImplTest, cloneNoInvalidation) {
+TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
@@ -316,7 +316,7 @@ TEST_F(PictureLayerImplTest, cloneNoInvalidation) {
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), active_pile.get());
 }
 
-TEST_F(PictureLayerImplTest, clonePartialInvalidation) {
+TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
@@ -354,7 +354,7 @@ TEST_F(PictureLayerImplTest, clonePartialInvalidation) {
   }
 }
 
-TEST_F(PictureLayerImplTest, cloneFullInvalidation) {
+TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
@@ -377,7 +377,7 @@ TEST_F(PictureLayerImplTest, cloneFullInvalidation) {
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), pending_pile.get());
 }
 
-TEST_F(PictureLayerImplTest, noInvalidationBoundsChange) {
+TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
   gfx::Size tile_size(90, 80);
   gfx::Size active_layer_bounds(300, 500);
   gfx::Size pending_layer_bounds(400, 800);
@@ -418,7 +418,7 @@ TEST_F(PictureLayerImplTest, noInvalidationBoundsChange) {
   }
 }
 
-TEST_F(PictureLayerImplTest, addTilesFromNewRecording) {
+TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index b437b2c..741526a 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -105,7 +105,7 @@ void RenderSurfaceImpl::DumpSurface(std::string* str, int indent) const {
 
   str->append(indent_str);
   base::StringAppendF(str,
-                      "damageRect is pos(%f, %f), size(%f, %f)\n",
+                      "current_damage_rect is pos(%f, %f), size(%f, %f)\n",
                       damage_tracker_->current_damage_rect().x(),
                       damage_tracker_->current_damage_rect().y(),
                       damage_tracker_->current_damage_rect().width(),
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index ec47b84..8720fb0 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -20,14 +20,14 @@
 namespace cc {
 namespace {
 
-#define EXECUTE_AND_VERIFY_SURFACE_CHANGED(codeToTest)                         \
+#define EXECUTE_AND_VERIFY_SURFACE_CHANGED(code_to_test)                       \
   render_surface->ResetPropertyChangedFlag();                                  \
-  codeToTest;                                                                  \
+  code_to_test;                                                                \
   EXPECT_TRUE(render_surface->SurfacePropertyChanged())
 
-#define EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(codeToTest)                  \
+#define EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(code_to_test)                \
   render_surface->ResetPropertyChangedFlag();                                  \
-  codeToTest;                                                                  \
+  code_to_test;                                                                \
   EXPECT_FALSE(render_surface->SurfacePropertyChanged())
 
 TEST(RenderSurfaceTest, VerifySurfaceChangesAreTrackedProperly) {
diff --git a/cc/layers/scrollbar_geometry_fixed_thumb.cc b/cc/layers/scrollbar_geometry_fixed_thumb.cc
index aaca66e..66dd293 100644
--- a/cc/layers/scrollbar_geometry_fixed_thumb.cc
+++ b/cc/layers/scrollbar_geometry_fixed_thumb.cc
@@ -54,14 +54,14 @@ void ScrollbarGeometryFixedThumb::splitTrack(
     WebRect& before_thumb_rect,
     WebRect& thumb_rect,
     WebRect& after_thumb_rect) {
-    // This is a reimplementation of ScrollbarThemeComposite::splitTrack.
+    // This is a reimplementation of ScrollbarThemeComposite::splitTrack().
     // Because the WebScrollbarThemeGeometry functions call down to native
     // ScrollbarThemeComposite code which uses ScrollbarThemeComposite virtual
-    // helpers, there's no way to override a helper like thumbLength from
+    // helpers, there's no way to override a helper like thumbLength() from
     // the WebScrollbarThemeGeometry level. So, these three functions
-    // (splitTrack, thumb_position, thumbLength) are copied here so that the
-    // WebScrollbarThemeGeometry helper functions are used instead and
-    // a fixed size thumbLength can be used.
+    // (splitTrack(), thumbPosition(), thumbLength()) are copied here so that
+    // the WebScrollbarThemeGeometry helper functions are used instead and
+    // a fixed size thumbLength() can be used.
 
     WebRect track_rect =
         constrainTrackRectToTrackPieces(scrollbar, unconstrained_track_rect);
diff --git a/cc/layers/scrollbar_layer.cc b/cc/layers/scrollbar_layer.cc
index 0570e22..7dac99e 100644
--- a/cc/layers/scrollbar_layer.cc
+++ b/cc/layers/scrollbar_layer.cc
@@ -30,22 +30,22 @@ scoped_refptr<ScrollbarLayer> ScrollbarLayer::Create(
     scoped_ptr<WebKit::WebScrollbar> scrollbar,
     scoped_ptr<ScrollbarThemePainter> painter,
     scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
-    int scrollLayerId) {
+    int scroll_layer_id) {
   return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(),
                                                painter.Pass(),
                                                geometry.Pass(),
-                                               scrollLayerId));
+                                               scroll_layer_id));
 }
 
 ScrollbarLayer::ScrollbarLayer(
     scoped_ptr<WebKit::WebScrollbar> scrollbar,
     scoped_ptr<ScrollbarThemePainter> painter,
     scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
-    int scrollLayerId)
+    int scroll_layer_id)
     : scrollbar_(scrollbar.Pass()),
       painter_(painter.Pass()),
       geometry_(geometry.Pass()),
-      scroll_layer_id_(scrollLayerId),
+      scroll_layer_id_(scroll_layer_id),
       texture_format_(GL_INVALID_ENUM) {
   if (!scrollbar_->isOverlay())
     SetShouldScrollOnMainThread(true);
@@ -96,15 +96,15 @@ void ScrollbarLayer::CalculateContentsScale(float ideal_contents_scale,
                                             bool animating_transform_to_screen,
                                             float* contents_scale_x,
                                             float* contents_scale_y,
-                                            gfx::Size* contentBounds) {
+                                            gfx::Size* content_bounds) {
   ContentsScalingLayer::CalculateContentsScale(
       ClampScaleToMaxTextureSize(ideal_contents_scale),
       animating_transform_to_screen,
       contents_scale_x,
       contents_scale_y,
-      contentBounds);
-  DCHECK_LE(contentBounds->width(), MaxTextureSize());
-  DCHECK_LE(contentBounds->height(), MaxTextureSize());
+      content_bounds);
+  DCHECK_LE(content_bounds->width(), MaxTextureSize());
+  DCHECK_LE(content_bounds->height(), MaxTextureSize());
 }
 
 void ScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
@@ -134,7 +134,7 @@ void ScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   else
     scrollbar_layer->set_thumb_resource_id(0);
 
-  // Pinch zoom scrollbarLayerImpl does not get its scroll_layer_id_
+  // Pinch zoom ScrollbarLayerImpl does not get its scroll_layer_id_
   // set in LayerImpl, so we need to push it here.
   if (scroll_layer_id_ == Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID)
     scrollbar_layer->set_scroll_layer_id(scroll_layer_id_);
@@ -338,7 +338,7 @@ void ScrollbarLayer::UpdatePart(CachingBitmapContentLayerUpdater* painter,
   if (!painter->pixels_did_change() &&
       resource->texture()->have_backing_texture()) {
     TRACE_EVENT_INSTANT0("cc",
-                         "ScrollbarLayer::updatePart no texture upload needed");
+                         "ScrollbarLayer::UpdatePart no texture upload needed");
     return;
   }
 
diff --git a/cc/layers/scrollbar_layer.h b/cc/layers/scrollbar_layer.h
index eafdde8..db97272 100644
--- a/cc/layers/scrollbar_layer.h
+++ b/cc/layers/scrollbar_layer.h
@@ -24,10 +24,10 @@ class CC_EXPORT ScrollbarLayer : public ContentsScalingLayer {
       OVERRIDE;
 
   static scoped_refptr<ScrollbarLayer> Create(
-      scoped_ptr<WebKit::WebScrollbar>,
-      scoped_ptr<ScrollbarThemePainter>,
-      scoped_ptr<WebKit::WebScrollbarThemeGeometry>,
-      int scrollLayerId);
+      scoped_ptr<WebKit::WebScrollbar> scrollbar,
+      scoped_ptr<ScrollbarThemePainter> painter,
+      scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
+      int scroll_layer_id);
 
   int scroll_layer_id() const { return scroll_layer_id_; }
   void SetScrollLayerId(int id);
@@ -48,16 +48,16 @@ class CC_EXPORT ScrollbarLayer : public ContentsScalingLayer {
                                       bool animating_transform_to_screen,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* contentBounds) OVERRIDE;
+                                      gfx::Size* content_bounds) OVERRIDE;
 
   virtual ScrollbarLayer* ToScrollbarLayer() OVERRIDE;
 
  protected:
   ScrollbarLayer(
-      scoped_ptr<WebKit::WebScrollbar>,
-      scoped_ptr<ScrollbarThemePainter>,
-      scoped_ptr<WebKit::WebScrollbarThemeGeometry>,
-      int scrollLayerId);
+      scoped_ptr<WebKit::WebScrollbar> scrollbar,
+      scoped_ptr<ScrollbarThemePainter> painter,
+      scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
+      int scroll_layer_id);
   virtual ~ScrollbarLayer();
 
  private:
diff --git a/cc/layers/scrollbar_layer_impl.cc b/cc/layers/scrollbar_layer_impl.cc
index 4e2d08c..c376449 100644
--- a/cc/layers/scrollbar_layer_impl.cc
+++ b/cc/layers/scrollbar_layer_impl.cc
@@ -151,8 +151,8 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
   bool flipped = false;
   gfx::PointF uv_top_left(0.f, 0.f);
   gfx::PointF uv_bottom_right(1.f, 1.f);
-  gfx::Rect boundsRect(bounds());
-  gfx::Rect contentBoundsRect(content_bounds());
+  gfx::Rect bounds_rect(bounds());
+  gfx::Rect content_bounds_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
@@ -191,12 +191,12 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
     return;
   }
 
-  WebRect thumb_rect, back_track_rect, foreTrackRect;
+  WebRect thumb_rect, back_track_rect, fore_track_rect;
   geometry_->splitTrack(&scrollbar_,
                         geometry_->trackRect(&scrollbar_),
                         back_track_rect,
                         thumb_rect,
-                        foreTrackRect);
+                        fore_track_rect);
   if (!geometry_->hasThumb(&scrollbar_))
     thumb_rect = WebRect();
 
@@ -222,11 +222,11 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
 
   // We only paint the track in two parts if we were given a texture for the
   // forward track part.
-  if (fore_track_resource_id_ && !foreTrackRect.isEmpty()) {
+  if (fore_track_resource_id_ && !fore_track_rect.isEmpty()) {
     gfx::Rect quad_rect(ScrollbarLayerRectToContentRect(
-        gfx::Rect(foreTrackRect)));
+        gfx::Rect(fore_track_rect)));
     gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
-    gfx::RectF uv_rect(ToUVRect(foreTrackRect, boundsRect));
+    gfx::RectF uv_rect(ToUVRect(fore_track_rect, bounds_rect));
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
@@ -244,8 +244,8 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
   // Order matters here: since the back track texture is being drawn to the
   // entire contents rect, we must append it after the thumb and fore track
   // quads. The back track texture contains (and displays) the buttons.
-  if (!contentBoundsRect.IsEmpty()) {
-    gfx::Rect quad_rect(contentBoundsRect);
+  if (!content_bounds_rect.IsEmpty()) {
+    gfx::Rect quad_rect(content_bounds_rect);
     gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index aca731d..423776d 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -91,7 +91,7 @@ TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
 
   // Create and attach a non-overlay scrollbar.
   scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
-  static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(false);
+  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(false);
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
   ScrollbarLayerImpl* scrollbar_layer_impl =
@@ -106,7 +106,7 @@ TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
 
   // Create and attach an overlay scrollbar.
   scrollbar = FakeWebScrollbar::Create();
-  static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(true);
+  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(true);
 
   layer_impl_tree_root =
       LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
@@ -190,7 +190,7 @@ TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   FakeLayerTreeHostImpl host_impl(layer_tree_settings, &proxy);
 
   scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
-  static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(true);
+  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(true);
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
   ScrollbarLayerImpl* scrollbar_layer_impl =
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 114386e..87c2377 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -32,12 +32,12 @@ void SolidColorLayerImpl::AppendQuads(QuadSink* quad_sink,
   int height = content_bounds().height();
   for (int x = 0; x < width; x += tile_size_) {
     for (int y = 0; y < height; y += tile_size_) {
-      gfx::Rect solidTileRect(x,
+      gfx::Rect solid_tile_rect(x,
                               y,
                               std::min(width - x, tile_size_),
                               std::min(height - y, tile_size_));
       scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-      quad->SetNew(shared_quad_state, solidTileRect, background_color());
+      quad->SetNew(shared_quad_state, solid_tile_rect, background_color());
       quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
     }
   }
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 0d9ac61..b95ca0c 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -109,9 +109,9 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
   scoped_refptr<Layer> root = Layer::Create();
   root->AddChild(layer);
 
-  std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
+  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
   LayerTreeHostCommon::CalculateDrawProperties(
-      root, gfx::Size(500, 500), 1, 1, 1024, false, &renderSurfaceLayerList);
+      root, gfx::Size(500, 500), 1, 1, 1024, false, &render_surface_layer_list);
 
   EXPECT_FALSE(layer->contents_opaque());
   layer->SetBackgroundColor(SkColorSetARGBInline(255, 10, 20, 30));
@@ -124,7 +124,7 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     // The impl layer should call itself opaque as well.
     EXPECT_TRUE(layer_impl->contents_opaque());
 
-    // Impl layer has 1 opacity, and the color is opaque, so the opaqueRect
+    // Impl layer has 1 opacity, and the color is opaque, so the opaque_rect
     // should be the full tile.
     layer_impl->draw_properties().opacity = 1;
 
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index f42c87a..47c92d8 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -323,7 +323,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
         break;
       case 2:
         // Old mailbox was released, task was posted, but won't execute
-        // until this didCommit returns.
+        // until this DidCommit returns.
         // TODO(piman): fix this.
         EXPECT_EQ(1, callback_count_);
         layer_tree_host()->SetNeedsCommit();
@@ -337,7 +337,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
         break;
       case 4:
         // Old mailbox was released, task was posted, but won't execute
-        // until this didCommit returns.
+        // until this DidCommit returns.
         // TODO(piman): fix this.
         EXPECT_EQ(2, callback_count_);
         layer_tree_host()->SetNeedsCommit();
@@ -350,7 +350,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
         break;
       case 6:
         // Old mailbox was released, task was posted, but won't execute
-        // until this didCommit returns.
+        // until this DidCommit returns.
         // TODO(piman): fix this.
         EXPECT_EQ(3, callback_count_);
         layer_tree_host()->SetNeedsCommit();
@@ -398,9 +398,9 @@ TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) {
   pending_layer = TextureLayerImpl::Create(host_impl_.pending_tree(), 1, true);
   ASSERT_TRUE(pending_layer);
 
-  scoped_ptr<LayerImpl> activeLayer(
+  scoped_ptr<LayerImpl> active_layer(
       pending_layer->CreateLayerImpl(host_impl_.active_tree()));
-  ASSERT_TRUE(activeLayer);
+  ASSERT_TRUE(active_layer);
 
   pending_layer->SetTextureMailbox(test_data_.mailbox1_);
 
@@ -412,8 +412,8 @@ TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) {
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test callback after activation.
-  pending_layer->PushPropertiesTo(activeLayer.get());
-  activeLayer->DidBecomeActive();
+  pending_layer->PushPropertiesTo(active_layer.get());
+  active_layer->DidBecomeActive();
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _)).Times(0);
   pending_layer->SetTextureMailbox(test_data_.mailbox1_);
@@ -421,16 +421,16 @@ TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) {
 
   EXPECT_CALL(test_data_.mock_callback_, Release(test_data_.mailbox_name2_, _))
       .Times(1);
-  pending_layer->PushPropertiesTo(activeLayer.get());
-  activeLayer->DidBecomeActive();
+  pending_layer->PushPropertiesTo(active_layer.get());
+  active_layer->DidBecomeActive();
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test resetting the mailbox.
   EXPECT_CALL(test_data_.mock_callback_, Release(test_data_.mailbox_name1_, _))
       .Times(1);
   pending_layer->SetTextureMailbox(TextureMailbox());
-  pending_layer->PushPropertiesTo(activeLayer.get());
-  activeLayer->DidBecomeActive();
+  pending_layer->PushPropertiesTo(active_layer.get());
+  active_layer->DidBecomeActive();
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test destructor.
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 0345cc0..e0f4da5 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -110,8 +110,8 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
-    gfx::Rect outsideBounds(gfx::Point(-100, -100), gfx::Size(50, 50));
-    layer->draw_properties().visible_content_rect = outsideBounds;
+    gfx::Rect outside_bounds(gfx::Point(-100, -100), gfx::Size(50, 50));
+    layer->draw_properties().visible_content_rect = outside_bounds;
 
     MockQuadCuller quad_culler;
     AppendQuadsData data;
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 79d3f0b..e852bb1 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -763,7 +763,7 @@ TEST_F(TiledLayerTest, VerifyUpdateRectWhenContentBoundsAreScaled) {
   layer->SetContentBounds(content_bounds.size());
   layer->draw_properties().visible_content_rect = content_bounds;
 
-  // On first update, the updateRect includes all tiles, even beyond the
+  // On first update, the update_rect includes all tiles, even beyond the
   // boundaries of the layer.
   // However, it should still be in layer space, not content space.
   layer->InvalidateContentRect(content_bounds);
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 5efbd49..f47596b 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -86,11 +86,11 @@ void VideoLayerImpl::WillDraw(ResourceProvider* resource_provider) {
 
 
   // Explicitly acquire and release the provider mutex so it can be held from
-  // willDraw to didDraw. Since the compositor thread is in the middle of
-  // drawing, the layer will not be destroyed before didDraw is called.
+  // WillDraw to DidDraw. Since the compositor thread is in the middle of
+  // drawing, the layer will not be destroyed before DidDraw is called.
   // Therefore, the only thing that will prevent this lock from being released
   // is the GPU process locking it. As the GPU process can't cause the
-  // destruction of the provider (calling stopUsingProvider), holding this
+  // destruction of the provider (calling StopUsingProvider), holding this
   // lock should not cause a deadlock.
   frame_ = provider_client_impl_->AcquireLockAndCurrentFrame();
 
diff --git a/cc/output/delegating_renderer.cc b/cc/output/delegating_renderer.cc
index 313093a..d6d24c2 100644
--- a/cc/output/delegating_renderer.cc
+++ b/cc/output/delegating_renderer.cc
@@ -73,50 +73,50 @@ bool DelegatingRenderer::Initialize() {
   context3d->setContextLostCallback(this);
   context3d->pushGroupMarkerEXT("CompositorContext");
 
-  std::string extensionsString =
+  std::string extensions_string =
       UTF16ToASCII(context3d->getString(GL_EXTENSIONS));
 
   std::vector<std::string> extensions;
-  base::SplitString(extensionsString, ' ', &extensions);
+  base::SplitString(extensions_string, ' ', &extensions);
 
   // TODO(danakj): We need non-GPU-specific paths for these things. This
   // renderer shouldn't need to use context3d extensions directly.
-  bool hasReadBGRA = true;
-  bool hasSetVisibility = true;
-  bool hasIOSurface = true;
-  bool hasARBTextureRect = true;
-  bool hasGpuMemoryManager = true;
-  bool hasEGLImage = true;
+  bool has_read_bgra = true;
+  bool has_set_visibility = true;
+  bool has_io_surface = true;
+  bool has_arb_texture_rect = true;
+  bool has_gpu_memory_manager = true;
+  bool has_egl_image = true;
   for (size_t i = 0; i < extensions.size(); ++i) {
     if (extensions[i] == "GL_EXT_read_format_bgra")
-      hasReadBGRA = true;
+      has_read_bgra = true;
     else if (extensions[i] == "GL_CHROMIUM_set_visibility")
-      hasSetVisibility = true;
+      has_set_visibility = true;
     else if (extensions[i] == "GL_CHROMIUM_iosurface")
-      hasIOSurface = true;
+      has_io_surface = true;
     else if (extensions[i] == "GL_ARB_texture_rectangle")
-      hasARBTextureRect = true;
+      has_arb_texture_rect = true;
     else if (extensions[i] == "GL_CHROMIUM_gpu_memory_manager")
-      hasGpuMemoryManager = true;
+      has_gpu_memory_manager = true;
     else if (extensions[i] == "GL_OES_EGL_image_external")
-      hasEGLImage = true;
+      has_egl_image = true;
   }
 
-  if (hasIOSurface)
-    DCHECK(hasARBTextureRect);
+  if (has_io_surface)
+    DCHECK(has_arb_texture_rect);
 
   capabilities_.using_accelerated_painting =
       Settings().accelerate_painting &&
       capabilities_.best_texture_format == GL_BGRA_EXT &&
-      hasReadBGRA;
+      has_read_bgra;
 
   // TODO(piman): loop visibility to GPU process?
-  capabilities_.using_set_visibility = hasSetVisibility;
+  capabilities_.using_set_visibility = has_set_visibility;
 
   // TODO(danakj): Support GpuMemoryManager.
   capabilities_.using_gpu_memory_manager = false;
 
-  capabilities_.using_egl_image = hasEGLImage;
+  capabilities_.using_egl_image = has_egl_image;
 
   return true;
 }
@@ -140,7 +140,7 @@ static ResourceProvider::ResourceId AppendToArray(
 
 void DelegatingRenderer::DrawFrame(
     RenderPassList& render_passes_in_draw_order) {
-  TRACE_EVENT0("cc", "DelegatingRenderer::drawFrame");
+  TRACE_EVENT0("cc", "DelegatingRenderer::DrawFrame");
 
   CompositorFrame out_frame;
   out_frame.metadata = client_->MakeCompositorFrameMetadata();
diff --git a/cc/output/delegating_renderer_unittest.cc b/cc/output/delegating_renderer_unittest.cc
index bd53886..c0b8dff 100644
--- a/cc/output/delegating_renderer_unittest.cc
+++ b/cc/output/delegating_renderer_unittest.cc
@@ -95,7 +95,7 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
     frame->render_passes.clear();
     frame->render_passes_by_id.clear();
 
-    TestRenderPass* child_pass = addRenderPass(
+    TestRenderPass* child_pass = AddRenderPass(
         frame->render_passes,
         RenderPass::Id(2, 1),
         gfx::Rect(3, 3, 10, 10),
@@ -103,7 +103,7 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
     child_pass->AppendOneOfEveryQuadType(
         host_impl->resource_provider(), RenderPass::Id(0, 0));
 
-    TestRenderPass* pass = addRenderPass(
+    TestRenderPass* pass = AddRenderPass(
         frame->render_passes,
         RenderPass::Id(1, 1),
         gfx::Rect(3, 3, 10, 10),
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 2f7905c..d398f16 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -68,12 +68,12 @@ gfx::RectF DirectRenderer::QuadVertexRect() {
 
 // static
 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
-                                       const gfx::Transform& quadTransform,
-                                       const gfx::RectF& quadRect) {
-  *quad_rect_transform = quadTransform;
-  quad_rect_transform->Translate(0.5 * quadRect.width() + quadRect.x(),
-                                 0.5 * quadRect.height() + quadRect.y());
-  quad_rect_transform->Scale(quadRect.width(), quadRect.height());
+                                       const gfx::Transform& quad_transform,
+                                       const gfx::RectF& quad_rect) {
+  *quad_rect_transform = quad_transform;
+  quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
+                                 0.5 * quad_rect.height() + quad_rect.y());
+  quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
 // static
@@ -131,27 +131,27 @@ void DirectRenderer::SetEnlargePassTextureAmountForTesting(
 
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
-  base::hash_map<RenderPass::Id, const RenderPass*> renderPassesInFrame;
+  base::hash_map<RenderPass::Id, const RenderPass*> render_passes_in_frame;
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
-    renderPassesInFrame.insert(std::pair<RenderPass::Id, const RenderPass*>(
+    render_passes_in_frame.insert(std::pair<RenderPass::Id, const RenderPass*>(
         render_passes_in_draw_order[i]->id, render_passes_in_draw_order[i]));
 
   std::vector<RenderPass::Id> passes_to_delete;
-  ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator passIterator;
-  for (passIterator = render_pass_textures_.begin();
-       passIterator != render_pass_textures_.end();
-       ++passIterator) {
+  ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator pass_iter;
+  for (pass_iter = render_pass_textures_.begin();
+       pass_iter != render_pass_textures_.end();
+       ++pass_iter) {
     base::hash_map<RenderPass::Id, const RenderPass*>::const_iterator it =
-        renderPassesInFrame.find(passIterator->first);
-    if (it == renderPassesInFrame.end()) {
-      passes_to_delete.push_back(passIterator->first);
+        render_passes_in_frame.find(pass_iter->first);
+    if (it == render_passes_in_frame.end()) {
+      passes_to_delete.push_back(pass_iter->first);
       continue;
     }
 
     const RenderPass* render_pass_in_frame = it->second;
     gfx::Size required_size = RenderPassTextureSize(render_pass_in_frame);
     GLenum required_format = RenderPassTextureFormat(render_pass_in_frame);
-    CachedResource* texture = passIterator->second;
+    CachedResource* texture = pass_iter->second;
     DCHECK(texture);
 
     bool size_appropriate = texture->size().width() >= required_size.width() &&
@@ -177,7 +177,7 @@ void DirectRenderer::DecideRenderPassAllocationsForFrame(
 }
 
 void DirectRenderer::DrawFrame(RenderPassList& render_passes_in_draw_order) {
-  TRACE_EVENT0("cc", "DirectRenderer::drawFrame");
+  TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
                        render_passes_in_draw_order.size());
 
@@ -206,12 +206,12 @@ gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
   if (frame.root_damage_rect == frame.root_render_pass->output_rect)
     return render_pass_scissor;
 
-  gfx::Transform inverseTransform(gfx::Transform::kSkipInitialization);
+  gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
   if (frame.current_render_pass->transform_to_root_target.GetInverse(
-          &inverseTransform)) {
+          &inverse_transform)) {
     // Only intersect inverse-projected damage if the transform is invertible.
     gfx::RectF damage_rect_in_render_pass_space =
-        MathUtil::ProjectClippedRect(inverseTransform, frame.root_damage_rect);
+        MathUtil::ProjectClippedRect(inverse_transform, frame.root_damage_rect);
     render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
   }
 
@@ -251,7 +251,7 @@ void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DrawRenderPass(DrawingFrame& frame,
                                     const RenderPass* render_pass) {
-  TRACE_EVENT0("cc", "DirectRenderer::drawRenderPass");
+  TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
@@ -271,8 +271,8 @@ void DirectRenderer::DrawRenderPass(DrawingFrame& frame,
   }
 
   const QuadList& quad_list = render_pass->quad_list;
-  for (QuadList::constBackToFrontIterator it = quad_list.backToFrontBegin();
-       it != quad_list.backToFrontEnd();
+  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
+       it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = *(*it);
     bool should_skip_quad = false;
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index b88e1b1..dc1d1c8 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -213,8 +213,8 @@ void GLRenderer::SetVisible(bool visible) {
 
   EnforceMemoryPolicy();
 
-  // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage
-  // front/backbuffers
+  // TODO: Replace setVisibilityCHROMIUM() with an extension to explicitly
+  // manage front/backbuffers
   // crbug.com/116049
   if (capabilities_.using_set_visibility)
     context_->setVisibilityCHROMIUM(visible);
@@ -256,7 +256,7 @@ void GLRenderer::BeginDrawingFrame(DrawingFrame& frame) {
   if (ViewportSize().IsEmpty())
     return;
 
-  TRACE_EVENT0("cc", "GLRenderer::drawLayers");
+  TRACE_EVENT0("cc", "GLRenderer::DrawLayers");
   if (is_viewport_changed_) {
     // Only reshape when we know we are going to draw. Otherwise, the reshape
     // can leave the window at the wrong size if we never draw and the proper
@@ -1339,7 +1339,7 @@ void GLRenderer::FlushTextureQuadCache() {
     // causing platform differences in some layout tests (see
     // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use
     // a separate blend function for the alpha channel to avoid modifying it.
-    // Don't use colorMask for this as it has performance implications on some
+    // Don't use colorMask() for this as it has performance implications on some
     // platforms.
     GLC(Context(),
         Context()->blendFuncSeparate(
@@ -1471,7 +1471,7 @@ void GLRenderer::DrawTextureQuad(const DrawingFrame& frame,
     // causing platform differences in some layout tests (see
     // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use
     // a separate blend function for the alpha channel to avoid modifying it.
-    // Don't use colorMask for this as it has performance implications on some
+    // Don't use colorMask() for this as it has performance implications on some
     // platforms.
     GLC(Context(),
         Context()->blendFuncSeparate(
@@ -1650,7 +1650,7 @@ bool GLRenderer::SwapBuffers() {
   DCHECK(visible_);
   DCHECK(!is_backbuffer_discarded_);
 
-  TRACE_EVENT0("cc", "GLRenderer::swapBuffers");
+  TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   if (capabilities_.using_partial_swap) {
@@ -1734,7 +1734,7 @@ ManagedMemoryPolicy::PriorityCutoff GLRenderer::PriorityCutoff(
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible_) {
-    TRACE_EVENT0("cc", "GLRenderer::enforceMemoryPolicy dropping resources");
+    TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     if (discard_backbuffer_when_not_visible_)
       DiscardBackbuffer();
@@ -1780,8 +1780,8 @@ void GLRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
   GLuint temporary_fbo = 0;
 
   if (do_workaround) {
-    // On Mac OS X, calling glReadPixels against an FBO whose color attachment
-    // is an IOSurface-backed texture causes corruption of future glReadPixels
+    // On Mac OS X, calling glReadPixels() against an FBO whose color attachment
+    // is an IOSurface-backed texture causes corruption of future glReadPixels()
     // calls, even those on different OpenGL contexts. It is believed that this
     // is the root cause of top crasher
     // http://crbug.com/99393. <rdar://problem/10949687>
@@ -1951,7 +1951,7 @@ void GLRenderer::SetDrawViewportSize(gfx::Size viewport_size) {
 bool GLRenderer::MakeContextCurrent() { return context_->makeContextCurrent(); }
 
 bool GLRenderer::InitializeSharedObjects() {
-  TRACE_EVENT0("cc", "GLRenderer::initializeSharedObjects");
+  TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
   MakeContextCurrent();
 
   // Create an FBO for doing offscreen rendering.
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index e6a668d..8dd2c64 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -156,7 +156,7 @@ class CC_EXPORT GLRenderer :
                                 const gfx::Transform& draw_matrix);
 
   // Check if quad needs antialiasing and if so, inflate the quad and
-  // fill edge array for fragment shader.  localQuad is set to
+  // fill edge array for fragment shader.  local_quad is set to
   // inflated quad if antialiasing is required, otherwise it is left
   // unchanged.  edge array is filled with inflated quad's edge data
   // if antialiasing is required, otherwise it is left unchanged.
diff --git a/cc/output/gl_renderer_pixeltest.cc b/cc/output/gl_renderer_pixeltest.cc
index bd00069..fbccce1 100644
--- a/cc/output/gl_renderer_pixeltest.cc
+++ b/cc/output/gl_renderer_pixeltest.cc
@@ -69,7 +69,7 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
 
 
 #if !defined(OS_ANDROID)
-TEST_F(GLRendererPixelTest, simpleGreenRect) {
+TEST_F(GLRendererPixelTest, SimpleGreenRect) {
   gfx::Rect rect(device_viewport_size_);
 
   RenderPass::Id id(1, 1);
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 537da0e..8ebcd4d 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -232,7 +232,7 @@ class GLRendererTest : public testing::Test {
   FakeRendererGL renderer_;
 };
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest recreating framebuffer when one already exists.
 // Expected: it does nothing.
 TEST_F(GLRendererTest, SuggestBackbufferYesWhenItAlreadyExistsShouldDoNothing) {
@@ -244,7 +244,7 @@ TEST_F(GLRendererTest, SuggestBackbufferYesWhenItAlreadyExistsShouldDoNothing) {
   EXPECT_EQ(1, context()->frame_count());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one exists and the renderer is not
 // visible.
 // Expected: it is discarded and damage tracker is reset.
@@ -256,7 +256,7 @@ TEST_F(GLRendererTest,
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one exists and the renderer is visible.
 // Expected: the allocation is ignored.
 TEST_F(GLRendererTest, SuggestBackbufferNoDoNothingWhenVisible) {
@@ -266,7 +266,7 @@ TEST_F(GLRendererTest, SuggestBackbufferNoDoNothingWhenVisible) {
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Suggest discarding framebuffer when one does not exist.
 // Expected: it does nothing.
 TEST_F(GLRendererTest, SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) {
@@ -280,7 +280,7 @@ TEST_F(GLRendererTest, SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) {
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
 }
 
-// Test GLRenderer discardBackbuffer functionality:
+// Test GLRenderer DiscardBackbuffer functionality:
 // Begin drawing a frame while a framebuffer is discarded.
 // Expected: will recreate framebuffer.
 TEST_F(GLRendererTest, DiscardedBackbufferIsRecreatedForScopeDuration) {
@@ -668,7 +668,7 @@ TEST(GLRendererTest2, VisibilityChangeIsLastCall) {
   bool last_call_was_set_visiblity = false;
   // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
-  // enforceManagedMemoryPolicy is called. Plumb this tracking between both the
+  // EnforceManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
   context->set_last_call_was_set_visibility_pointer(&last_call_was_set_visiblity);
@@ -766,9 +766,9 @@ TEST(GLRendererTest2, ActiveTextureState) {
   renderer.BeginDrawingFrame(drawing_frame);
   EXPECT_EQ(context->active_texture(), GL_TEXTURE0);
 
-  for (cc::QuadList::backToFrontIterator
-           it = pass->quad_list.backToFrontBegin();
-       it != pass->quad_list.backToFrontEnd();
+  for (cc::QuadList::BackToFrontIterator
+           it = pass->quad_list.BackToFrontBegin();
+       it != pass->quad_list.BackToFrontEnd();
        ++it) {
     renderer.DoDrawQuad(drawing_frame, *it);
   }
@@ -812,16 +812,16 @@ TEST(GLRendererTest2, ShouldClearRootRenderPass) {
   render_passes.clear();
 
   RenderPass::Id root_pass_id(1, 0);
-  TestRenderPass* root_pass = addRenderPass(
+  TestRenderPass* root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_pass, viewport_rect, SK_ColorGREEN);
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
   RenderPass::Id child_pass_id(2, 0);
-  TestRenderPass* child_pass = addRenderPass(
+  TestRenderPass* child_pass = AddRenderPass(
       render_passes, child_pass_id, viewport_rect, gfx::Transform());
-  addQuad(child_pass, viewport_rect, SK_ColorBLUE);
+  AddQuad(child_pass, viewport_rect, SK_ColorBLUE);
 
-  addRenderPassQuad(root_pass, child_pass);
+  AddRenderPassQuad(root_pass, child_pass);
 
   // First render pass is not the root one, clearing should happen.
   EXPECT_CALL(*mock_context, clear(GL_COLOR_BUFFER_BIT)).Times(AtLeast(1));
@@ -884,23 +884,23 @@ TEST(GLRendererTest2, ScissorTestWhenClearing) {
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPass::Id grand_child_pass_id(3, 0);
-  TestRenderPass* grand_child_pass = addRenderPass(
+  TestRenderPass* grand_child_pass = AddRenderPass(
       render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
-  addClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
+  AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
   gfx::Rect child_rect(50, 50);
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass =
-      addRenderPass(render_passes, child_pass_id, child_rect, gfx::Transform());
-  addQuad(child_pass, child_rect, SK_ColorBLUE);
+      AddRenderPass(render_passes, child_pass_id, child_rect, gfx::Transform());
+  AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
   RenderPass::Id root_pass_id(1, 0);
-  TestRenderPass* root_pass = addRenderPass(
+  TestRenderPass* root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_pass, viewport_rect, SK_ColorGREEN);
+  AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  addRenderPassQuad(root_pass, child_pass);
-  addRenderPassQuad(child_pass, grand_child_pass);
+  AddRenderPassQuad(root_pass, child_pass);
+  AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(
       *mock_client.render_passes_in_draw_order());
@@ -964,9 +964,9 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
     render_passes->clear();
 
     RenderPass::Id render_pass_id(1, 0);
-    TestRenderPass* render_pass = addRenderPass(
+    TestRenderPass* render_pass = AddRenderPass(
         *render_passes, render_pass_id, viewport_rect, gfx::Transform());
-    addQuad(render_pass, viewport_rect, SK_ColorGREEN);
+    AddQuad(render_pass, viewport_rect, SK_ColorGREEN);
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
diff --git a/cc/output/output_surface.cc b/cc/output/output_surface.cc
index 34ba8d0..f084788 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/output_surface.cc
@@ -58,10 +58,10 @@ bool OutputSurface::BindToClient(
   if (!context3d_->makeContextCurrent())
     return false;
 
-  string extensionsString = UTF16ToASCII(context3d_->getString(GL_EXTENSIONS));
-  vector<string> extensionsList;
-  base::SplitString(extensionsString, ' ', &extensionsList);
-  set<string> extensions(extensionsList.begin(), extensionsList.end());
+  string extensions_string = UTF16ToASCII(context3d_->getString(GL_EXTENSIONS));
+  vector<string> extensions_list;
+  base::SplitString(extensions_string, ' ', &extensions_list);
+  set<string> extensions(extensions_list.begin(), extensions_list.end());
 
   has_gl_discard_backbuffer_ =
       extensions.count("GL_CHROMIUM_discard_backbuffer");
@@ -97,7 +97,7 @@ void OutputSurface::BindFramebuffer() {
 
 void OutputSurface::SwapBuffers() {
   DCHECK(context3d_);
-  // Note that currently this has the same effect as swapBuffers; we should
+  // Note that currently this has the same effect as SwapBuffers; we should
   // consider exposing a different entry point on WebGraphicsContext3D.
   context3d_->prepareTexture();
 }
diff --git a/cc/output/render_surface_filters.cc b/cc/output/render_surface_filters.cc
index dd5e1a1..2c51fbc 100644
--- a/cc/output/render_surface_filters.cc
+++ b/cc/output/render_surface_filters.cc
@@ -45,7 +45,7 @@ void GetContrastMatrix(float amount, SkScalar matrix[20]) {
 }
 
 void GetSaturateMatrix(float amount, SkScalar matrix[20]) {
-  // Note, these values are computed to ensure matrixNeedsClamping is false
+  // Note, these values are computed to ensure MatrixNeedsClamping is false
   // for amount in [0..1]
   matrix[0] = 0.213f + 0.787f * amount;
   matrix[1] = 0.715f - 0.715f * amount;
@@ -99,7 +99,7 @@ void GetOpacityMatrix(float amount, SkScalar matrix[20]) {
 }
 
 void GetGrayscaleMatrix(float amount, SkScalar matrix[20]) {
-  // Note, these values are computed to ensure matrixNeedsClamping is false
+  // Note, these values are computed to ensure MatrixNeedsClamping is false
   // for amount in [0..1]
   matrix[0] = 0.2126f + 0.7874f * amount;
   matrix[1] = 0.7152f - 0.7152f * amount;
@@ -323,10 +323,10 @@ WebKit::WebFilterOperations RenderSurfaceFilters::Optimize(
     SkScalar matrix[20];
     if (GetColorMatrix(op, matrix)) {
       if (have_accumulated_color_matrix) {
-        SkScalar newMatrix[20];
-        MultColorMatrix(matrix, accumulated_color_matrix, newMatrix);
+        SkScalar new_matrix[20];
+        MultColorMatrix(matrix, accumulated_color_matrix, new_matrix);
         memcpy(accumulated_color_matrix,
-               newMatrix,
+               new_matrix,
                sizeof(accumulated_color_matrix));
       } else {
         memcpy(accumulated_color_matrix,
diff --git a/cc/output/software_output_device.cc b/cc/output/software_output_device.cc
index 37efb64..e63322a 100644
--- a/cc/output/software_output_device.cc
+++ b/cc/output/software_output_device.cc
@@ -42,11 +42,11 @@ void SoftwareOutputDevice::EndPaint(SoftwareFrameData* frame_data) {
 void SoftwareOutputDevice::CopyToBitmap(
     gfx::Rect rect, SkBitmap* output) {
   DCHECK(device_);
-  SkIRect invertRect = SkIRect::MakeXYWH(
+  SkIRect invert_rect = SkIRect::MakeXYWH(
       rect.x(), viewport_size_.height() - rect.bottom(),
       rect.width(), rect.height());
   const SkBitmap& bitmap = device_->accessBitmap(false);
-  bitmap.extractSubset(output, invertRect);
+  bitmap.extractSubset(output, invert_rect);
 }
 
 void SoftwareOutputDevice::Scroll(
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 0806418..3b97ea0 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -270,8 +270,10 @@ void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame& frame,
   // We need to apply the matrix manually to have pixel-sized stroke width.
   SkPoint vertices[4];
   gfx::RectFToSkRect(QuadVertexRect()).toQuad(vertices);
-  SkPoint transformedVertices[4];
-  current_canvas_->getTotalMatrix().mapPoints(transformedVertices, vertices, 4);
+  SkPoint transformed_vertices[4];
+  current_canvas_->getTotalMatrix().mapPoints(transformed_vertices,
+                                              vertices,
+                                              4);
   current_canvas_->resetMatrix();
 
   current_paint_.setColor(quad->color);
@@ -279,7 +281,7 @@ void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame& frame,
   current_paint_.setStyle(SkPaint::kStroke_Style);
   current_paint_.setStrokeWidth(quad->width);
   current_canvas_->drawPoints(SkCanvas::kPolygon_PointMode,
-                              4, transformedVertices, current_paint_);
+                              4, transformed_vertices, current_paint_);
 }
 
 void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame& frame,
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 61559ad..b58e148 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -218,8 +218,8 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   // Draw a fullscreen green quad in a first frame.
   RenderPass::Id root_clear_pass_id(1, 0);
   TestRenderPass* root_clear_pass =
-      addRenderPass(list, root_clear_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_clear_pass, viewport_rect, SK_ColorGREEN);
+      AddRenderPass(list, root_clear_pass_id, viewport_rect, gfx::Transform());
+  AddQuad(root_clear_pass, viewport_rect, SK_ColorGREEN);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
   renderer()->DrawFrame(list);
@@ -235,9 +235,9 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   gfx::Rect smaller_rect(20, 20, 60, 60);
 
   RenderPass::Id root_smaller_pass_id(2, 0);
-  TestRenderPass* root_smaller_pass = addRenderPass(
+  TestRenderPass* root_smaller_pass = AddRenderPass(
       list, root_smaller_pass_id, viewport_rect, gfx::Transform());
-  addQuad(root_smaller_pass, smaller_rect, SK_ColorMAGENTA);
+  AddQuad(root_smaller_pass, smaller_rect, SK_ColorMAGENTA);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
   renderer()->DrawFrame(list);
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index 952472d..2636a07 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -53,7 +53,7 @@ class CC_EXPORT DrawQuad {
   gfx::Rect opaque_rect;
 
   // Allows changing the rect that gets drawn to make it smaller. This value
-  // should be clipped to quadRect.
+  // should be clipped to |rect|.
   gfx::Rect visible_rect;
 
   // By default blending is used when some part of the quad is not opaque.
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 496602c..281da3b 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -192,22 +192,22 @@ void CompareDrawQuad(DrawQuad* quad,
     } \
     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 
-#define CREATE_QUAD_5_NEW_1(Type, a, b, c, d, e, copyA) \
+#define CREATE_QUAD_5_NEW_1(Type, a, b, c, d, e, copy_a) \
     scoped_ptr<Type> quad_new(Type::Create()); \
     { \
       QUAD_DATA \
       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e); \
     } \
-    SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copyA);
+    SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
 
-#define CREATE_QUAD_5_ALL_1(Type, a, b, c, d, e, copyA) \
+#define CREATE_QUAD_5_ALL_1(Type, a, b, c, d, e, copy_a) \
     scoped_ptr<Type> quad_all(Type::Create()); \
     { \
       QUAD_DATA \
       quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
                        quad_visible_rect, needs_blending, a, b, c, d, e); \
     } \
-    SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copyA);
+    SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
 
 #define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \
     scoped_ptr<Type> quad_new(Type::Create()); \
@@ -262,15 +262,15 @@ void CompareDrawQuad(DrawQuad* quad,
     } \
     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 
-#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copyA) \
+#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copy_a) \
     scoped_ptr<Type> quad_new(Type::Create()); \
     { \
       QUAD_DATA \
       quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g, h); \
     } \
-    SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copyA);
+    SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
 
-#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copyA) \
+#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copy_a) \
     scoped_ptr<Type> quad_all(Type::Create()); \
     { \
       QUAD_DATA \
@@ -278,7 +278,7 @@ void CompareDrawQuad(DrawQuad* quad,
                        quad_visible_rect, needs_blending, \
                        a, b, c, d, e, f, g, h); \
     } \
-    SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copyA);
+    SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
 
 #define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \
     scoped_ptr<Type> quad_new(Type::Create()); \
diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h
index 6259716..154b02c5 100644
--- a/cc/quads/render_pass.h
+++ b/cc/quads/render_pass.h
@@ -28,13 +28,13 @@ class SharedQuadState;
 // A list of DrawQuad objects, sorted internally in front-to-back order.
 class QuadList : public ScopedPtrVector<DrawQuad> {
  public:
-  typedef reverse_iterator backToFrontIterator;
-  typedef const_reverse_iterator constBackToFrontIterator;
+  typedef reverse_iterator BackToFrontIterator;
+  typedef const_reverse_iterator ConstBackToFrontIterator;
 
-  inline backToFrontIterator backToFrontBegin() { return rbegin(); }
-  inline backToFrontIterator backToFrontEnd() { return rend(); }
-  inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); }
-  inline constBackToFrontIterator backToFrontEnd() const { return rend(); }
+  inline BackToFrontIterator BackToFrontBegin() { return rbegin(); }
+  inline BackToFrontIterator BackToFrontEnd() { return rend(); }
+  inline ConstBackToFrontIterator BackToFrontBegin() const { return rbegin(); }
+  inline ConstBackToFrontIterator BackToFrontEnd() const { return rend(); }
 };
 
 typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList;
@@ -64,7 +64,7 @@ class CC_EXPORT RenderPass {
   static scoped_ptr<RenderPass> Create();
 
   // A shallow copy of the render pass, which does not include its quads.
-  scoped_ptr<RenderPass> Copy(Id newId) const;
+  scoped_ptr<RenderPass> Copy(Id new_id) const;
 
   void SetNew(Id id,
               gfx::Rect output_rect,
diff --git a/cc/quads/texture_draw_quad.cc b/cc/quads/texture_draw_quad.cc
index 6b3958f..04c9511 100644
--- a/cc/quads/texture_draw_quad.cc
+++ b/cc/quads/texture_draw_quad.cc
@@ -91,13 +91,13 @@ bool TextureDrawQuad::PerformClipping() {
       static_cast<float>(quadTransform().matrix().getDouble(1, 3)));
 
   // Transform the rect by the scale and offset.
-  gfx::RectF rectF = rect;
-  rectF.Scale(x_scale, y_scale);
-  rectF += offset;
+  gfx::RectF rect_f = rect;
+  rect_f.Scale(x_scale, y_scale);
+  rect_f += offset;
 
   // Perform clipping and check to see if the result is empty.
-  gfx::RectF clippedRect = IntersectRects(rectF, clipRect());
-  if (clippedRect.IsEmpty()) {
+  gfx::RectF clipped_rect = IntersectRects(rect_f, clipRect());
+  if (clipped_rect.IsEmpty()) {
     rect = gfx::Rect();
     uv_top_left = gfx::PointF();
     uv_bottom_right = gfx::PointF();
@@ -106,15 +106,15 @@ bool TextureDrawQuad::PerformClipping() {
 
   // Create a new uv-rect by clipping the old one to the new bounds.
   gfx::Vector2dF uv_scale(uv_bottom_right - uv_top_left);
-  uv_scale.Scale(1.f / rectF.width(), 1.f / rectF.height());
+  uv_scale.Scale(1.f / rect_f.width(), 1.f / rect_f.height());
   uv_bottom_right = uv_top_left +
       gfx::ScaleVector2d(
-          clippedRect.bottom_right() - rectF.origin(),
+          clipped_rect.bottom_right() - rect_f.origin(),
           uv_scale.x(),
           uv_scale.y());
   uv_top_left = uv_top_left +
       gfx::ScaleVector2d(
-          clippedRect.origin() - rectF.origin(),
+          clipped_rect.origin() - rect_f.origin(),
           uv_scale.x(),
           uv_scale.y());
 
@@ -125,10 +125,10 @@ bool TextureDrawQuad::PerformClipping() {
   if (vertex_opacity[0] != vertex_opacity[1]
       || vertex_opacity[0] != vertex_opacity[2]
       || vertex_opacity[0] != vertex_opacity[3]) {
-    const float x1 = (clippedRect.x() - rectF.x()) / rectF.width();
-    const float y1 = (clippedRect.y() - rectF.y()) / rectF.height();
-    const float x3 = (clippedRect.right() - rectF.x()) / rectF.width();
-    const float y3 = (clippedRect.bottom() - rectF.y()) / rectF.height();
+    const float x1 = (clipped_rect.x() - rect_f.x()) / rect_f.width();
+    const float y1 = (clipped_rect.y() - rect_f.y()) / rect_f.height();
+    const float x3 = (clipped_rect.right() - rect_f.x()) / rect_f.width();
+    const float y3 = (clipped_rect.bottom() - rect_f.y()) / rect_f.height();
     const float x1y1 = x1 * vertex_opacity[2] + (1.0f - x1) * vertex_opacity[1];
     const float x1y3 = x1 * vertex_opacity[3] + (1.0f - x1) * vertex_opacity[0];
     const float x3y1 = x3 * vertex_opacity[2] + (1.0f - x3) * vertex_opacity[1];
@@ -140,12 +140,12 @@ bool TextureDrawQuad::PerformClipping() {
   }
 
   // Move the clipped rectangle back into its space.
-  clippedRect -= offset;
-  clippedRect.Scale(1.0f / x_scale, 1.0f / y_scale);
-  rect = gfx::Rect(static_cast<int>(clippedRect.x() + 0.5f),
-                   static_cast<int>(clippedRect.y() + 0.5f),
-                   static_cast<int>(clippedRect.width() + 0.5f),
-                   static_cast<int>(clippedRect.height() + 0.5f));
+  clipped_rect -= offset;
+  clipped_rect.Scale(1.0f / x_scale, 1.0f / y_scale);
+  rect = gfx::Rect(static_cast<int>(clipped_rect.x() + 0.5f),
+                   static_cast<int>(clipped_rect.y() + 0.5f),
+                   static_cast<int>(clipped_rect.width() + 0.5f),
+                   static_cast<int>(clipped_rect.height() + 0.5f));
   return true;
 }
 
diff --git a/cc/resources/bitmap_skpicture_content_layer_updater.h b/cc/resources/bitmap_skpicture_content_layer_updater.h
index 07bef12..63ca4a1 100644
--- a/cc/resources/bitmap_skpicture_content_layer_updater.h
+++ b/cc/resources/bitmap_skpicture_content_layer_updater.h
@@ -10,9 +10,9 @@
 
 namespace cc {
 
-// This class records the contentRect into an SkPicture, then software
+// This class records the content_rect into an SkPicture, then software
 // rasterizes the SkPicture into bitmaps for each tile. This implements
-// Settings::perTilePainting.
+// LayerTreeSettingSettings::per_tile_painting_enabled.
 class BitmapSkPictureContentLayerUpdater : public SkPictureContentLayerUpdater {
  public:
   class Resource : public ContentLayerUpdater::Resource {
diff --git a/cc/resources/content_layer_updater.cc b/cc/resources/content_layer_updater.cc
index 4865a49..f11083b 100644
--- a/cc/resources/content_layer_updater.cc
+++ b/cc/resources/content_layer_updater.cc
@@ -28,7 +28,7 @@ void ContentLayerUpdater::PaintContents(SkCanvas* canvas,
                                         float contents_height_scale,
                                         gfx::Rect* resulting_opaque_rect,
                                         RenderingStats* stats) {
-  TRACE_EVENT0("cc", "ContentLayerUpdater::paintContents");
+  TRACE_EVENT0("cc", "ContentLayerUpdater::PaintContents");
   canvas->save();
   canvas->translate(SkFloatToScalar(-content_rect.x()),
                     SkFloatToScalar(-content_rect.y()));
diff --git a/cc/resources/content_layer_updater.h b/cc/resources/content_layer_updater.h
index bedc614..80b8a48 100644
--- a/cc/resources/content_layer_updater.h
+++ b/cc/resources/content_layer_updater.h
@@ -17,7 +17,7 @@ class LayerPainter;
 
 // Base class for BitmapContentLayerUpdater and
 // SkPictureContentLayerUpdater that reduces code duplication between
-// their respective paintContents implementations.
+// their respective PaintContents implementations.
 class CC_EXPORT ContentLayerUpdater : public LayerUpdater {
  protected:
   explicit ContentLayerUpdater(scoped_ptr<LayerPainter> painter);
diff --git a/cc/resources/picture.cc b/cc/resources/picture.cc
index 8ec6e98..701d8ac 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -17,7 +17,7 @@
 
 namespace {
 // URI label for a lazily decoded SkPixelRef.
-const char labelLazyDecoded[] = "lazy";
+const char kLabelLazyDecoded[] = "lazy";
 
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
@@ -81,15 +81,15 @@ void Picture::CloneForDrawing(int num_threads) {
 
 void Picture::Record(ContentLayerClient* painter,
                      RenderingStats* stats,
-                     const SkTileGridPicture::TileGridInfo& tileGridInfo) {
+                     const SkTileGridPicture::TileGridInfo& tile_grid_info) {
   TRACE_EVENT2("cc", "Picture::Record",
                "width", layer_rect_.width(), "height", layer_rect_.height());
 
   // Record() should only be called once.
   DCHECK(!picture_);
-  DCHECK(!tileGridInfo.fTileInterval.isEmpty());
+  DCHECK(!tile_grid_info.fTileInterval.isEmpty());
   picture_ = skia::AdoptRef(new SkTileGridPicture(
-      layer_rect_.width(), layer_rect_.height(), tileGridInfo));
+      layer_rect_.width(), layer_rect_.height(), tile_grid_info));
 
   SkCanvas* canvas = picture_->beginRecording(
       layer_rect_.width(),
@@ -171,7 +171,7 @@ void Picture::GatherPixelRefs(const gfx::Rect& layer_rect,
   SkPixelRef** refs = reinterpret_cast<SkPixelRef**>(data);
   for (unsigned int i = 0; i < pixel_refs->size() / sizeof(SkPixelRef*); ++i) {
     if (*refs && (*refs)->getURI() && !strncmp(
-        (*refs)->getURI(), labelLazyDecoded, 4)) {
+        (*refs)->getURI(), kLabelLazyDecoded, 4)) {
       pixel_ref_list.push_back(static_cast<skia::LazyPixelRef*>(*refs));
     }
     refs++;
diff --git a/cc/resources/picture.h b/cc/resources/picture.h
index 9d08bfa..3cb6791 100644
--- a/cc/resources/picture.h
+++ b/cc/resources/picture.h
@@ -44,7 +44,7 @@ class CC_EXPORT Picture
   // Record a paint operation. To be able to safely use this SkPicture for
   // playback on a different thread this can only be called once.
   void Record(ContentLayerClient*, RenderingStats*,
-      const SkTileGridPicture::TileGridInfo& tileGridInfo);
+      const SkTileGridPicture::TileGridInfo& tile_grid_info);
 
   // Has Record() been called yet?
   bool HasRecording() const { return picture_.get() != NULL; }
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index 1cc6190..3d97b43 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -233,10 +233,10 @@ void PicturePileImpl::AnalyzeInRect(const gfx::Rect& content_rect,
   gfx::Rect layer_rect = gfx::ToEnclosingRect(
       gfx::ScaleRect(content_rect, 1.f / contents_scale));
 
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, content_rect.width(),
+  SkBitmap empty_bitmap;
+  empty_bitmap.setConfig(SkBitmap::kNo_Config, content_rect.width(),
                         content_rect.height());
-  skia::AnalysisDevice device(emptyBitmap);
+  skia::AnalysisDevice device(empty_bitmap);
   skia::AnalysisCanvas canvas(&device);
 
   int64 total_pixels_rasterized = 0;
diff --git a/cc/resources/picture_pile_impl.h b/cc/resources/picture_pile_impl.h
index 2f2fe00..6e76fc2 100644
--- a/cc/resources/picture_pile_impl.h
+++ b/cc/resources/picture_pile_impl.h
@@ -29,7 +29,7 @@ class CC_EXPORT PicturePileImpl : public PicturePileBase {
 
   // Raster a subrect of this PicturePileImpl into the given canvas.
   // It's only safe to call paint on a cloned version.
-  // It is assumed that contentsScale has already been applied to this canvas.
+  // It is assumed that contents_scale has already been applied to this canvas.
   void Raster(
       SkCanvas* canvas,
       gfx::Rect canvas_rect,
diff --git a/cc/resources/prioritized_resource_manager.cc b/cc/resources/prioritized_resource_manager.cc
index e3eea72..2c406df 100644
--- a/cc/resources/prioritized_resource_manager.cc
+++ b/cc/resources/prioritized_resource_manager.cc
@@ -307,17 +307,17 @@ void PrioritizedResourceManager::ReduceWastedMemory(
   // we really need very little memory. This should probably be solved by
   // reducing the limit externally, but until then this just does some "clean
   // up" of unused backing textures (any more than 10%).
-  size_t wastedMemory = 0;
+  size_t wasted_memory = 0;
   for (BackingList::iterator it = backings_.begin(); it != backings_.end();
        ++it) {
     if ((*it)->owner())
       break;
-    wastedMemory += (*it)->bytes();
+    wasted_memory += (*it)->bytes();
   }
-  size_t tenPercentOfMemory = memory_available_bytes_ / 10;
-  if (wastedMemory > tenPercentOfMemory)
+  size_t ten_percent_of_memory = memory_available_bytes_ / 10;
+  if (wasted_memory > ten_percent_of_memory)
     EvictBackingsToReduceMemory(MemoryUseBytes() -
-                                (wastedMemory - tenPercentOfMemory),
+                                (wasted_memory - ten_percent_of_memory),
                                 PriorityCalculator::AllowEverythingCutoff(),
                                 EVICT_ONLY_RECYCLABLE,
                                 DO_NOT_UNLINK_BACKINGS,
@@ -515,7 +515,7 @@ void PrioritizedResourceManager::AssertInvariants() {
 
   // At all times, backings that can be evicted must always come before
   // backings that can't be evicted in the backing texture list (otherwise
-  // reduceMemory will not find all textures available for eviction/recycling).
+  // ReduceMemory will not find all textures available for eviction/recycling).
   bool reached_unrecyclable = false;
   PrioritizedResource::Backing* previous_backing = NULL;
   for (BackingList::iterator it = backings_.begin(); it != backings_.end();
diff --git a/cc/resources/prioritized_resource_manager.h b/cc/resources/prioritized_resource_manager.h
index 820ed41..b1f013d 100644
--- a/cc/resources/prioritized_resource_manager.h
+++ b/cc/resources/prioritized_resource_manager.h
@@ -82,7 +82,7 @@ class CC_EXPORT PrioritizedResourceManager {
   void ClearPriorities();
 
   // Delete contents textures' backing resources until they use only
-  // bytesLimit bytes. This may be called on the impl thread while the main
+  // limit_bytes bytes. This may be called on the impl thread while the main
   // thread is running. Returns true if resources are indeed evicted as a
   // result of this call.
   bool ReduceMemoryOnImplThread(size_t limit_bytes,
@@ -189,7 +189,7 @@ class CC_EXPORT PrioritizedResourceManager {
 
   size_t max_memory_limit_bytes_;
   // The priority cutoff based on memory pressure. This is not a strict
-  // cutoff -- requestLate allows textures with priority equal to this
+  // cutoff -- RequestLate allows textures with priority equal to this
   // cutoff to be allowed.
   int priority_cutoff_;
   // The priority cutoff based on external memory policy. This is a strict
@@ -220,11 +220,11 @@ class CC_EXPORT PrioritizedResourceManager {
   TextureVector temp_texture_vector_;
 
   // Statistics about memory usage at priority cutoffs, computed at
-  // prioritizeTextures.
+  // PrioritizeTextures.
   size_t memory_visible_bytes_;
   size_t memory_visible_and_nearby_bytes_;
 
-  // Statistics copied at the time of pushTexturePrioritiesToBackings.
+  // Statistics copied at the time of PushTexturePrioritiesToBackings.
   size_t memory_visible_last_pushed_bytes_;
   size_t memory_visible_and_nearby_last_pushed_bytes_;
 
diff --git a/cc/resources/prioritized_resource_unittest.cc b/cc/resources/prioritized_resource_unittest.cc
index 7b10d72..98e4985 100644
--- a/cc/resources/prioritized_resource_unittest.cc
+++ b/cc/resources/prioritized_resource_unittest.cc
@@ -623,7 +623,7 @@ TEST_F(PrioritizedResourceTest, RequestLateBackingsSorting) {
         EXPECT_TRUE(ValidateTexture(textures[i], false));
 
     // Drop the memory limit and prioritize (none will be above the threshold,
-    // but they still have backings because reduceMemory hasn't been called).
+    // but they still have backings because ReduceMemory hasn't been called).
     resource_manager->SetMaxMemoryLimitBytes(
         TexturesMemorySize(max_textures / 2));
     PrioritizeTexturesAndBackings(resource_manager.get());
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index a1246f4..d8de6f5 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -87,7 +87,7 @@ class ContextSharedData {
 
     // If the latest sync point the context has waited on is before the sync
     // point for when the mailbox was set, pretend we never saw that
-    // produceTexture.
+    // ProduceTexture.
     if (sync_point_for_mailbox_[mailbox] > sync_point) {
       NOTREACHED();
       return scoped_ptr<Texture>();
@@ -233,7 +233,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
     ASSERT_EQ(target, GL_TEXTURE_2D);
 
     // Delay moving the texture into the mailbox until the next
-    // insertSyncPoint, so that it is not visible to other contexts that
+    // InsertSyncPoint, so that it is not visible to other contexts that
     // haven't waited on that sync point.
     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
@@ -840,13 +840,13 @@ TEST_P(ResourceProviderTest, ScopedSampler) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TextureStateTrackingContext)));
   TextureStateTrackingContext* context =
-      static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
+      static_cast<TextureStateTrackingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
@@ -913,13 +913,13 @@ TEST_P(ResourceProviderTest, ManagedResource) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TextureStateTrackingContext)));
   TextureStateTrackingContext* context =
-      static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
+      static_cast<TextureStateTrackingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
@@ -1002,7 +1002,7 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
@@ -1014,9 +1014,9 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   // Lazy allocation. Don't allocate when creating the resource.
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
@@ -1042,7 +1042,7 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
   resource_provider->DeleteResource(id);
   Mock::VerifyAndClearExpectations(context);
 
-  // Same for setPixelsFromBuffer
+  // Same for SetPixelsFromBuffer
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
@@ -1078,7 +1078,7 @@ TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
@@ -1087,9 +1087,9 @@ TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
@@ -1113,7 +1113,7 @@ TEST_P(ResourceProviderTest, AbortForcedAsyncUpload) {
   scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
       static_cast<WebKit::WebGraphicsContext3D*>(
           new NiceMock<AllocationTrackingContext3D>));
-  scoped_ptr<OutputSurface> outputSurface(
+  scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(mock_context.Pass()));
 
   gfx::Size size(2, 2);
@@ -1122,9 +1122,9 @@ TEST_P(ResourceProviderTest, AbortForcedAsyncUpload) {
   int texture_id = 123;
 
   AllocationTrackingContext3D* context =
-      static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
+      static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(outputSurface.get()));
+      ResourceProvider::Create(output_surface.get()));
 
   EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(4);
diff --git a/cc/resources/resource_update_controller.cc b/cc/resources/resource_update_controller.cc
index baae7a9..3936b4d 100644
--- a/cc/resources/resource_update_controller.cc
+++ b/cc/resources/resource_update_controller.cc
@@ -34,13 +34,13 @@ const double kUploaderBusyTickRate = 0.001;
 const size_t kMaxBlockingUpdateIntervals = 4;
 
 skia::RefPtr<SkCanvas> CreateAcceleratedCanvas(
-    GrContext* gr_context, gfx::Size canvasSize, unsigned textureId) {
+    GrContext* gr_context, gfx::Size canvas_size, unsigned texture_id) {
   GrBackendTextureDesc texture_desc;
   texture_desc.fFlags = kRenderTarget_GrBackendTextureFlag;
-  texture_desc.fWidth = canvasSize.width();
-  texture_desc.fHeight = canvasSize.height();
+  texture_desc.fWidth = canvas_size.width();
+  texture_desc.fHeight = canvas_size.height();
   texture_desc.fConfig = kSkia8888_GrPixelConfig;
-  texture_desc.fTextureHandle = textureId;
+  texture_desc.fTextureHandle = texture_id;
   skia::RefPtr<GrTexture> target =
       skia::AdoptRef(gr_context->wrapBackendTexture(texture_desc));
   skia::RefPtr<SkDevice> device =
@@ -81,8 +81,8 @@ ResourceUpdateController::ResourceUpdateController(
 ResourceUpdateController::~ResourceUpdateController() {}
 
 void ResourceUpdateController::PerformMoreUpdates(
-    base::TimeTicks timeLimit) {
-  time_limit_ = timeLimit;
+    base::TimeTicks time_limit) {
+  time_limit_ = time_limit;
 
   // Update already in progress.
   if (task_posted_)
diff --git a/cc/resources/skpicture_content_layer_updater.cc b/cc/resources/skpicture_content_layer_updater.cc
index 0ca6ea8..6ce3df8 100644
--- a/cc/resources/skpicture_content_layer_updater.cc
+++ b/cc/resources/skpicture_content_layer_updater.cc
@@ -48,23 +48,23 @@ scoped_ptr<LayerUpdater::Resource> SkPictureContentLayerUpdater::CreateResource(
 void SkPictureContentLayerUpdater::PrepareToUpdate(
     gfx::Rect content_rect,
     gfx::Size,
-    float contentsWidthScale,
+    float contents_width_scale,
     float contents_height_scale,
-    gfx::Rect* resultingOpaqueRect,
+    gfx::Rect* resulting_opaque_rect,
     RenderingStats* stats) {
   SkCanvas* canvas =
       picture_.beginRecording(content_rect.width(), content_rect.height());
   PaintContents(canvas,
                 content_rect,
-                contentsWidthScale,
+                contents_width_scale,
                 contents_height_scale,
-                resultingOpaqueRect,
+                resulting_opaque_rect,
                 stats);
   picture_.endRecording();
 }
 
 void SkPictureContentLayerUpdater::DrawPicture(SkCanvas* canvas) {
-  TRACE_EVENT0("cc", "SkPictureContentLayerUpdater::drawPicture");
+  TRACE_EVENT0("cc", "SkPictureContentLayerUpdater::DrawPicture");
   canvas->drawPicture(picture_);
 }
 
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 76c2b89..83223b2 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -95,9 +95,9 @@ class CC_EXPORT TileManager : public WorkerPoolClient {
 
   scoped_ptr<base::Value> BasicStateAsValue() const;
   scoped_ptr<base::Value> AllTilesAsValue() const;
-  void GetMemoryStats(size_t* memoryRequiredBytes,
-                      size_t* memoryNiceToHaveBytes,
-                      size_t* memoryUsedBytes) const;
+  void GetMemoryStats(size_t* memory_required_bytes,
+                      size_t* memory_nice_to_have_bytes,
+                      size_t* memory_used_bytes) const;
   bool HasPendingWorkScheduled(WhichTree tree) const;
 
   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
diff --git a/cc/scheduler/delay_based_time_source.cc b/cc/scheduler/delay_based_time_source.cc
index 48cd31d..4037824 100644
--- a/cc/scheduler/delay_based_time_source.cc
+++ b/cc/scheduler/delay_based_time_source.cc
@@ -51,7 +51,7 @@ DelayBasedTimeSource::DelayBasedTimeSource(base::TimeDelta interval,
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 void DelayBasedTimeSource::SetActive(bool active) {
-  TRACE_EVENT1("cc", "DelayBasedTimeSource::setActive", "active", active);
+  TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
   if (!active) {
     state_ = STATE_INACTIVE;
     weak_factory_.InvalidateWeakPtrs();
@@ -152,7 +152,7 @@ base::TimeTicks DelayBasedTimeSource::Now() const {
 
 // This code tries to achieve an average tick rate as close to interval_ as
 // possible.  To do this, it has to deal with a few basic issues:
-//   1. postDelayedTask can delay only at a millisecond granularity. So, 16.666
+//   1. PostDelayedTask can delay only at a millisecond granularity. So, 16.666
 //   has to posted as 16 or 17.
 //   2. A delayed task may come back a bit late (a few ms), or really late
 //   (frames later)
@@ -162,7 +162,7 @@ base::TimeTicks DelayBasedTimeSource::Now() const {
 //
 // Then, when we post our task, we take the floor of (tick_target_ and Now()).
 // If we started at now=0, and 60FPs (all times in milliseconds):
-//      now=0    target=16.667   postDelayedTask(16)
+//      now=0    target=16.667   PostDelayedTask(16)
 //
 // When our callback runs, we figure out how far off we were from that goal.
 // Because of the flooring operation, and assuming our timer runs exactly when
@@ -172,18 +172,18 @@ base::TimeTicks DelayBasedTimeSource::Now() const {
 // Since we can't post a 0.667 ms task to get to now=16, we just treat this as a
 // tick. Then, we update target to be 33.333. We now post another task based on
 // the difference between our target and now:
-//      now=16   tick_target=16.667  newTarget=33.333   -->
-//          postDelayedTask(floor(33.333 - 16)) --> postDelayedTask(17)
+//      now=16   tick_target=16.667  new_target=33.333   -->
+//          PostDelayedTask(floor(33.333 - 16)) --> PostDelayedTask(17)
 //
 // Over time, with no late tasks, this leads to us posting tasks like this:
-//      now=0    tick_target=0       newTarget=16.667   -->
-//          tick(), postDelayedTask(16)
-//      now=16   tick_target=16.667  newTarget=33.333   -->
-//          tick(), postDelayedTask(17)
-//      now=33   tick_target=33.333  newTarget=50.000   -->
-//          tick(), postDelayedTask(17)
-//      now=50   tick_target=50.000  newTarget=66.667   -->
-//          tick(), postDelayedTask(16)
+//      now=0    tick_target=0       new_target=16.667   -->
+//          tick(), PostDelayedTask(16)
+//      now=16   tick_target=16.667  new_target=33.333   -->
+//          tick(), PostDelayedTask(17)
+//      now=33   tick_target=33.333  new_target=50.000   -->
+//          tick(), PostDelayedTask(17)
+//      now=50   tick_target=50.000  new_target=66.667   -->
+//          tick(), PostDelayedTask(16)
 //
 // We treat delays in tasks differently depending on the amount of delay we
 // encounter. Suppose we posted a task with a target=16.667:
@@ -194,16 +194,16 @@ base::TimeTicks DelayBasedTimeSource::Now() const {
 //      now=25.0 tick_target=16.667
 //
 // We treat the first case as a tick anyway, and assume the delay was unusual.
-// Thus, we compute the newTarget based on the old timebase:
-//      now=18   tick_target=16.667  newTarget=33.333   -->
-//          tick(), postDelayedTask(floor(33.333-18)) --> postDelayedTask(15)
+// Thus, we compute the new_target based on the old timebase:
+//      now=18   tick_target=16.667  new_target=33.333   -->
+//          tick(), PostDelayedTask(floor(33.333-18)) --> PostDelayedTask(15)
 // This brings us back to 18+15 = 33, which was where we would have been if the
 // task hadn't been late.
 //
 // For the really late delay, we we move to the next logical tick. The timebase
 // is not reset.
-//      now=37   tick_target=16.667  newTarget=50.000  -->
-//          tick(), postDelayedTask(floor(50.000-37)) --> postDelayedTask(13)
+//      now=37   tick_target=16.667  new_target=50.000  -->
+//          tick(), PostDelayedTask(floor(50.000-37)) --> PostDelayedTask(13)
 base::TimeTicks DelayBasedTimeSource::NextTickTarget(base::TimeTicks now) {
   base::TimeDelta new_interval = next_parameters_.interval;
   int intervals_elapsed =
diff --git a/cc/scheduler/frame_rate_controller_unittest.cc b/cc/scheduler/frame_rate_controller_unittest.cc
index 9818a66..0ed600a 100644
--- a/cc/scheduler/frame_rate_controller_unittest.cc
+++ b/cc/scheduler/frame_rate_controller_unittest.cc
@@ -134,7 +134,7 @@ TEST(FrameRateControllerTest, TestFrameThrottling_Unthrottled) {
   controller.SetClient(&client);
   controller.SetMaxFramesPending(2);
 
-  // setActive triggers 1st frame, make sure the vsync callback is called
+  // SetActive triggers 1st frame, make sure the vsync callback is called
   controller.SetActive(true);
   thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
@@ -157,7 +157,7 @@ TEST(FrameRateControllerTest, TestFrameThrottling_Unthrottled) {
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
-  // DidBeginFrame triggers 3rd frame (> maxFramesPending),
+  // DidBeginFrame triggers 3rd frame (> max_frames_pending),
   // make sure the vsync callback is NOT called
   controller.DidBeginFrame();
   thread.RunPendingTask();
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 8393897..c1da5f2 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -77,13 +77,13 @@ void Scheduler::SetMainThreadNeedsLayerTextures() {
 }
 
 void Scheduler::BeginFrameComplete() {
-  TRACE_EVENT0("cc", "Scheduler::beginFrameComplete");
+  TRACE_EVENT0("cc", "Scheduler::BeginFrameComplete");
   state_machine_.BeginFrameComplete();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginFrameAborted() {
-  TRACE_EVENT0("cc", "Scheduler::beginFrameAborted");
+  TRACE_EVENT0("cc", "Scheduler::BeginFrameAborted");
   state_machine_.BeginFrameAborted();
   ProcessScheduledActions();
 }
@@ -101,18 +101,18 @@ void Scheduler::SetSwapBuffersCompleteSupported(bool supported) {
 }
 
 void Scheduler::DidSwapBuffersComplete() {
-  TRACE_EVENT0("cc", "Scheduler::didSwapBuffersComplete");
+  TRACE_EVENT0("cc", "Scheduler::DidSwapBuffersComplete");
   frame_rate_controller_->DidFinishFrame();
 }
 
 void Scheduler::DidLoseOutputSurface() {
-  TRACE_EVENT0("cc", "Scheduler::didLoseOutputSurface");
+  TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
   state_machine_.DidLoseOutputSurface();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidRecreateOutputSurface() {
-  TRACE_EVENT0("cc", "Scheduler::didRecreateOutputSurface");
+  TRACE_EVENT0("cc", "Scheduler::DidRecreateOutputSurface");
   frame_rate_controller_->DidAbortAllPendingFrames();
   state_machine_.DidRecreateOutputSurface();
   ProcessScheduledActions();
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 8471acc..63463db 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -102,18 +102,18 @@ class CC_EXPORT SchedulerStateMachine {
   // thread to main.
   void SetNeedsCommit();
 
-  // As SetNeedsCommit(), but ensures the beginFrame will definitely happen even
+  // As SetNeedsCommit(), but ensures the BeginFrame will definitely happen even
   // if we are not visible.  After this call we expect to go through the forced
-  // commit flow and then return to waiting for a non-forced beginFrame to
+  // commit flow and then return to waiting for a non-forced BeginFrame to
   // finish.
   void SetNeedsForcedCommit();
 
   // Call this only in response to receiving an ACTION_BEGIN_FRAME
-  // from nextState. Indicates that all painting is complete.
+  // from NextAction. Indicates that all painting is complete.
   void BeginFrameComplete();
 
   // Call this only in response to receiving an ACTION_BEGIN_FRAME
-  // from nextState if the client rejects the beginFrame message.
+  // from NextAction if the client rejects the BeginFrame message.
   void BeginFrameAborted();
 
   // Request exclusive access to the textures that back single buffered
@@ -126,7 +126,7 @@ class CC_EXPORT SchedulerStateMachine {
   void SetCanBeginFrame(bool can) { can_begin_frame_ = can; }
 
   // Indicates whether drawing would, at this time, make sense.
-  // canDraw can be used to supress flashes or checkerboarding
+  // CanDraw can be used to supress flashes or checkerboarding
   // when such behavior would be undesirable.
   void SetCanDraw(bool can);
 
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index cc26509..f15bb8f 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -59,7 +59,7 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded) {
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   }
 
-  // If commit requested but canBeginFrame is still false, do nothing.
+  // If commit requested but can_begin_frame is still false, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
@@ -85,7 +85,7 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded) {
     EXPECT_FALSE(state.VSyncCallbackNeeded());
   }
 
-  // Begin the frame, make sure needsCommit and commitState update correctly.
+  // Begin the frame, make sure needs_commit and commit_state update correctly.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCanBeginFrame(true);
@@ -371,18 +371,18 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnVSync) {
         state.SetVisible(true);
       }
 
-      // Case 1: needsCommit=false
+      // Case 1: needs_commit=false
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
-      // Case 2: needsCommit=true
+      // Case 2: needs_commit=true
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 
-  // When on vsync, or not on vsync but needsForcedRedraw set, should always
+  // When on vsync, or not on vsync but needs_forced_dedraw set, should always
   // draw except if you're ready to commit, in which case commit.
   for (size_t i = 0; i < num_commit_states; ++i) {
     for (size_t j = 0; j < 2; ++j) {
@@ -408,11 +408,11 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnVSync) {
         expected_action = SchedulerStateMachine::ACTION_COMMIT;
       }
 
-      // Case 1: needsCommit=false.
+      // Case 1: needs_commit=false.
       EXPECT_TRUE(state.VSyncCallbackNeeded());
       EXPECT_EQ(expected_action, state.NextAction());
 
-      // Case 2: needsCommit=true.
+      // Case 2: needs_commit=true.
       state.SetNeedsCommit();
       EXPECT_TRUE(state.VSyncCallbackNeeded());
       EXPECT_EQ(expected_action, state.NextAction());
@@ -436,11 +436,11 @@ TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible) {
       if (j == 1)
         state.DidEnterVSync();
 
-      // Case 1: needsCommit=false.
+      // Case 1: needs_commit=false.
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
-      // Case 2: needsCommit=true.
+      // Case 2: needs_commit=true.
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
@@ -648,7 +648,7 @@ TEST(SchedulerStateMachineTest, TestGoesInvisibleBeforeBeginFrameCompletes) {
   EXPECT_FALSE(state.NeedsCommit());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
-  // Become invisible and abort the beginFrame.
+  // Become invisible and abort the BeginFrame.
   state.SetVisible(false);
   state.BeginFrameAborted();
 
@@ -725,7 +725,7 @@ TEST(SchedulerStateMachineTest,
   state.UpdateState(state.NextAction());
 
   // Once the context is recreated, whether we draw should be based on
-  // setCanDraw.
+  // SetCanDraw.
   state.SetNeedsRedraw(true);
   state.DidEnterVSync();
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
diff --git a/cc/scheduler/texture_uploader.cc b/cc/scheduler/texture_uploader.cc
index b5d3422..dd89e8c 100644
--- a/cc/scheduler/texture_uploader.cc
+++ b/cc/scheduler/texture_uploader.cc
@@ -77,12 +77,12 @@ unsigned TextureUploader::Query::Value() {
 
 TextureUploader::TextureUploader(WebKit::WebGraphicsContext3D* context,
                                  bool use_map_tex_sub_image,
-                                 bool useShallowFlush)
+                                 bool use_shallow_flush)
     : context_(context),
       num_blocking_texture_uploads_(0),
       use_map_tex_sub_image_(use_map_tex_sub_image),
       sub_image_size_(0),
-      use_shallow_flush_(useShallowFlush),
+      use_shallow_flush_(use_shallow_flush),
       num_texture_uploads_since_last_flush_(0) {
   for (size_t i = kUploadHistorySizeInitial; i > 0; i--)
     textures_per_second_history_.insert(kDefaultEstimatedTexturesPerSecond);
@@ -202,7 +202,7 @@ void TextureUploader::UploadWithTexSubImage(const uint8* image,
   base::debug::Alias(&image_rect_height);
   base::debug::Alias(&dest_offset_x);
   base::debug::Alias(&dest_offset_y);
-  TRACE_EVENT0("cc", "TextureUploader::uploadWithTexSubImage");
+  TRACE_EVENT0("cc", "TextureUploader::UploadWithTexSubImage");
 
   // Offset from image-rect to source-rect.
   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
@@ -273,7 +273,7 @@ void TextureUploader::UploadWithMapTexSubImage(const uint8* image,
   base::debug::Alias(&dest_offset_x);
   base::debug::Alias(&dest_offset_y);
 
-  TRACE_EVENT0("cc", "TextureUploader::uploadWithMapTexSubImage");
+  TRACE_EVENT0("cc", "TextureUploader::UploadWithMapTexSubImage");
 
   // Offset from image-rect to source-rect.
   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
@@ -308,7 +308,7 @@ void TextureUploader::UploadWithMapTexSubImage(const uint8* image,
            source_rect.height() * image_rect.width() * bytes_per_pixel);
   } else {
     // Strides not equal, so do a row-by-row memcpy from the
-    // paint results into the pixelDest
+    // paint results into the pixel_dest.
     for (int row = 0; row < source_rect.height(); ++row) {
       memcpy(&pixel_dest[upload_image_stride * row],
              &image[bytes_per_pixel *
diff --git a/cc/scheduler/texture_uploader.h b/cc/scheduler/texture_uploader.h
index 46120c9..369348d 100644
--- a/cc/scheduler/texture_uploader.h
+++ b/cc/scheduler/texture_uploader.h
@@ -41,7 +41,7 @@ class CC_EXPORT TextureUploader {
   // Let content_rect be a rectangle, and let content_rect be a sub-rectangle of
   // content_rect, expressed in the same coordinate system as content_rect. Let
   // image be a buffer for content_rect. This function will copy the region
-  // corresponding to sourceRect to destOffset in this sub-image.
+  // corresponding to source_rect to dest_offset in this sub-image.
   void Upload(const uint8* image,
               gfx::Rect content_rect,
               gfx::Rect source_rect,
diff --git a/cc/test/animation_test_common.cc b/cc/test/animation_test_common.cc
index 9c025f2..4f9548d 100644
--- a/cc/test/animation_test_common.cc
+++ b/cc/test/animation_test_common.cc
@@ -21,27 +21,27 @@ using cc::TransformKeyframe;
 
 namespace cc {
 
-static int nextAnimationId = 0;
+static int s_next_animation_id = 0;
 
 template <class Target>
 int AddOpacityTransition(Target* target,
                          double duration,
-                         float startOpacity,
-                         float endOpacity,
-                         bool useTimingFunction) {
+                         float start_opacity,
+                         float end_opacity,
+                         bool use_timing_function) {
   scoped_ptr<KeyframedFloatAnimationCurve>
       curve(KeyframedFloatAnimationCurve::Create());
 
   scoped_ptr<TimingFunction> func;
-  if (!useTimingFunction)
+  if (!use_timing_function)
     func = EaseTimingFunction::Create();
   if (duration > 0.0)
-    curve->AddKeyframe(FloatKeyframe::Create(0.0, startOpacity, func.Pass()));
+    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
   curve->AddKeyframe(FloatKeyframe::Create(duration,
-                                           endOpacity,
+                                           end_opacity,
                                            scoped_ptr<cc::TimingFunction>()));
 
-  int id = nextAnimationId++;
+  int id = s_next_animation_id++;
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.PassAs<AnimationCurve>(),
@@ -57,28 +57,28 @@ int AddOpacityTransition(Target* target,
 template <class Target>
 int AddAnimatedTransform(Target* target,
                          double duration,
-                         int deltaX,
-                         int deltaY) {
+                         int delta_x,
+                         int delta_y) {
   scoped_ptr<KeyframedTransformAnimationCurve>
       curve(KeyframedTransformAnimationCurve::Create());
 
   if (duration > 0.0) {
-    TransformOperations startOperations;
-    startOperations.AppendTranslate(deltaX, deltaY, 0.0);
+    TransformOperations start_operations;
+    start_operations.AppendTranslate(delta_x, delta_y, 0.0);
     curve->AddKeyframe(TransformKeyframe::Create(
         0.0,
-        startOperations,
+        start_operations,
         scoped_ptr<cc::TimingFunction>()));
   }
 
   TransformOperations operations;
-  operations.AppendTranslate(deltaX, deltaY, 0.0);
+  operations.AppendTranslate(delta_x, delta_y, 0.0);
   curve->AddKeyframe(TransformKeyframe::Create(
       duration,
       operations,
       scoped_ptr<cc::TimingFunction>()));
 
-  int id = nextAnimationId++;
+  int id = s_next_animation_id++;
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.PassAs<AnimationCurve>(),
diff --git a/cc/test/fake_proxy.h b/cc/test/fake_proxy.h
index 3be3f46..b9d37a3 100644
--- a/cc/test/fake_proxy.h
+++ b/cc/test/fake_proxy.h
@@ -13,8 +13,8 @@ namespace cc {
 
 class FakeProxy : public Proxy {
  public:
-  explicit FakeProxy(scoped_ptr<Thread> implThread)
-      : Proxy(implThread.Pass()) {}
+  explicit FakeProxy(scoped_ptr<Thread> impl_thread)
+      : Proxy(impl_thread.Pass()) {}
 
   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
   virtual void StartPageScaleAnimation(gfx::Vector2d target_position,
diff --git a/cc/test/fake_web_scrollbar.cc b/cc/test/fake_web_scrollbar.cc
index 49a9de2..e536ff4 100644
--- a/cc/test/fake_web_scrollbar.cc
+++ b/cc/test/fake_web_scrollbar.cc
@@ -6,10 +6,6 @@
 
 namespace cc {
 
-void FakeWebScrollbar::setOverlay(bool is_overlay) {
-  is_overlay_ = is_overlay;
-}
-
 bool FakeWebScrollbar::isOverlay() const {
   return is_overlay_;
 }
diff --git a/cc/test/fake_web_scrollbar.h b/cc/test/fake_web_scrollbar.h
index 93ad943..331f715 100644
--- a/cc/test/fake_web_scrollbar.h
+++ b/cc/test/fake_web_scrollbar.h
@@ -16,7 +16,7 @@ class FakeWebScrollbar : public WebKit::WebScrollbar {
     return make_scoped_ptr(new FakeWebScrollbar());
   }
 
-  void setOverlay(bool isOverlay);
+  void set_overlay(bool is_overlay) { is_overlay_ = is_overlay; }
 
   // WebScrollbar implementation
   virtual bool isOverlay() const OVERRIDE;
diff --git a/cc/test/layer_tree_json_parser.cc b/cc/test/layer_tree_json_parser.cc
index 3b40170..435e2bf 100644
--- a/cc/test/layer_tree_json_parser.cc
+++ b/cc/test/layer_tree_json_parser.cc
@@ -79,9 +79,9 @@ scoped_refptr<Layer> ParseTreeFromValue(base::Value* val,
   for (int i = 0; i < 16; ++i)
     success &= list->GetDouble(i, &transform[i]);
 
-  gfx::Transform gfxTransform;
-  gfxTransform.matrix().setColMajord(transform);
-  new_layer->SetTransform(gfxTransform);
+  gfx::Transform layer_transform;
+  layer_transform.matrix().setColMajord(transform);
+  new_layer->SetTransform(layer_transform);
 
   success &= dict->GetList("Children", &list);
   for (ListValue::const_iterator it = list->begin();
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 5a56c14..7726142 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -320,7 +320,7 @@ LayerTreeTest::~LayerTreeTest() {}
 
 void LayerTreeTest::EndTest() {
   // For the case where we EndTest during BeginTest(), set a flag to indicate
-  // that the test should end the second beginTest regains control.
+  // that the test should end the second BeginTest regains control.
   if (beginning_) {
     end_when_begin_returns_ = true;
   } else if (proxy()) {
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index afc20b2..8302874 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -91,7 +91,7 @@ class TimeoutTask;
 // LayerTreeTest methods of similar names. To track the commit process, override
 // these functions.
 //
-// The test continues until someone calls endTest. endTest can be called on any
+// The test continues until someone calls EndTest. EndTest can be called on any
 // thread, but be aware that ending the test is an asynchronous process.
 class LayerTreeTest : public testing::Test, public TestHooks {
  public:
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index ec2199f..7ceaef9 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -29,48 +29,48 @@ void TestRenderPass::AppendSharedQuadState(
 }
 
 void TestRenderPass::AppendOneOfEveryQuadType(
-    cc::ResourceProvider* resourceProvider, RenderPass::Id child_pass) {
+    cc::ResourceProvider* resource_provider, RenderPass::Id child_pass) {
   gfx::Rect rect(0, 0, 100, 100);
   gfx::Rect opaque_rect(10, 10, 80, 80);
   const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
   cc::ResourceProvider::ResourceId texture_resource =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(20, 12),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(texture_resource);
+  resource_provider->AllocateForTesting(texture_resource);
   unsigned texture_id = ResourceProvider::ScopedReadLockGL(
-      resourceProvider, texture_resource).texture_id();
+      resource_provider, texture_resource).texture_id();
   cc::ResourceProvider::ResourceId resource1 =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(45, 5),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(resource1);
+  resource_provider->AllocateForTesting(resource1);
   cc::ResourceProvider::ResourceId resource2 =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(346, 61),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(resource2);
+  resource_provider->AllocateForTesting(resource2);
   cc::ResourceProvider::ResourceId resource3 =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(12, 134),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(resource3);
+  resource_provider->AllocateForTesting(resource3);
   cc::ResourceProvider::ResourceId resource4 =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(56, 12),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(resource4);
+  resource_provider->AllocateForTesting(resource4);
   cc::ResourceProvider::ResourceId resource5 =
-      resourceProvider->CreateResource(
+      resource_provider->CreateResource(
           gfx::Size(73, 26),
-          resourceProvider->best_texture_format(),
+          resource_provider->best_texture_format(),
           ResourceProvider::TextureUsageAny);
-  resourceProvider->AllocateForTesting(resource5);
+  resource_provider->AllocateForTesting(resource5);
 
   scoped_ptr<cc::SharedQuadState> shared_state = cc::SharedQuadState::Create();
   shared_state->SetAll(gfx::Transform(),
@@ -178,7 +178,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
   scoped_ptr<cc::SharedQuadState> transformed_state = shared_state->Copy();
   gfx::Transform rotation;
   rotation.Rotate(45);
-  transformed_state->content_to_target_transform = transformed_state->content_to_target_transform * rotation;
+  transformed_state->content_to_target_transform =
+      transformed_state->content_to_target_transform * rotation;
   scoped_ptr<cc::TileDrawQuad> transformed_tile_quad =
       cc::TileDrawQuad::Create();
   transformed_tile_quad->SetNew(transformed_state.get(),
@@ -204,11 +205,11 @@ void TestRenderPass::AppendOneOfEveryQuadType(
   cc::VideoLayerImpl::FramePlane planes[3];
   for (int i = 0; i < 3; ++i) {
     planes[i].resource_id =
-        resourceProvider->CreateResource(
+        resource_provider->CreateResource(
             gfx::Size(20, 12),
-            resourceProvider->best_texture_format(),
+            resource_provider->best_texture_format(),
             ResourceProvider::TextureUsageAny);
-    resourceProvider->AllocateForTesting(planes[i].resource_id);
+    resource_provider->AllocateForTesting(planes[i].resource_id);
     planes[i].size = gfx::Size(100, 100);
     planes[i].format = GL_LUMINANCE;
   }
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index f803b4c..e9614c4 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -15,61 +15,62 @@
 
 namespace cc {
 
-TestRenderPass* addRenderPass(RenderPassList& passList,
+TestRenderPass* AddRenderPass(RenderPassList& pass_list,
                               RenderPass::Id id,
-                              const gfx::Rect& outputRect,
-                              const gfx::Transform& rootTransform) {
+                              gfx::Rect output_rect,
+                              const gfx::Transform& root_transform) {
   scoped_ptr<TestRenderPass> pass(TestRenderPass::Create());
-  pass->SetNew(id, outputRect, outputRect, rootTransform);
+  pass->SetNew(id, output_rect, output_rect, root_transform);
   TestRenderPass* saved = pass.get();
-  passList.push_back(pass.PassAs<RenderPass>());
+  pass_list.push_back(pass.PassAs<RenderPass>());
   return saved;
 }
 
-SolidColorDrawQuad* addQuad(TestRenderPass* pass,
-                            const gfx::Rect& rect,
+SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
+                            gfx::Rect rect,
                             SkColor color) {
-  MockQuadCuller quadSink(&pass->quad_list, &pass->shared_quad_state_list);
+  MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
   AppendQuadsData data(pass->id);
-  SharedQuadState* sharedState =
-      quadSink.UseSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1);
+  SharedQuadState* shared_state =
+      quad_sink.UseSharedQuadState(SharedQuadState::Create());
+  shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-  quad->SetNew(sharedState, rect, color);
-  SolidColorDrawQuad* quadPtr = quad.get();
-  quadSink.Append(quad.PassAs<DrawQuad>(), &data);
-  return quadPtr;
+  quad->SetNew(shared_state, rect, color);
+  SolidColorDrawQuad* quad_ptr = quad.get();
+  quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
+  return quad_ptr;
 }
 
-SolidColorDrawQuad* addClippedQuad(TestRenderPass* pass,
-                                   const gfx::Rect& rect,
+SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
+                                   gfx::Rect rect,
                                    SkColor color) {
-  MockQuadCuller quadSink(&pass->quad_list, &pass->shared_quad_state_list);
+  MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
   AppendQuadsData data(pass->id);
-  SharedQuadState* sharedState =
-      quadSink.UseSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), rect.size(), rect, rect, true, 1);
+  SharedQuadState* shared_state =
+      quad_sink.UseSharedQuadState(SharedQuadState::Create());
+  shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, true, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-  quad->SetNew(sharedState, rect, color);
-  SolidColorDrawQuad* quadPtr = quad.get();
-  quadSink.Append(quad.PassAs<DrawQuad>(), &data);
-  return quadPtr;
+  quad->SetNew(shared_state, rect, color);
+  SolidColorDrawQuad* quad_ptr = quad.get();
+  quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
+  return quad_ptr;
 }
 
-void addRenderPassQuad(TestRenderPass* toPass,
-                       TestRenderPass* contributingPass) {
-  MockQuadCuller quadSink(&toPass->quad_list, &toPass->shared_quad_state_list);
-  AppendQuadsData data(toPass->id);
-  gfx::Rect outputRect = contributingPass->output_rect;
-  SharedQuadState* sharedState =
-      quadSink.UseSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(
-      gfx::Transform(), outputRect.size(), outputRect, outputRect, false, 1);
+void AddRenderPassQuad(TestRenderPass* to_pass,
+                       TestRenderPass* contributing_pass) {
+  MockQuadCuller quad_sink(&to_pass->quad_list,
+                           &to_pass->shared_quad_state_list);
+  AppendQuadsData data(to_pass->id);
+  gfx::Rect output_rect = contributing_pass->output_rect;
+  SharedQuadState* shared_state =
+      quad_sink.UseSharedQuadState(SharedQuadState::Create());
+  shared_state->SetAll(
+      gfx::Transform(), output_rect.size(), output_rect, output_rect, false, 1);
   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
-  quad->SetNew(sharedState, outputRect, contributingPass->id, false, 0,
-               outputRect, gfx::RectF(), WebKit::WebFilterOperations(),
+  quad->SetNew(shared_state, output_rect, contributing_pass->id, false, 0,
+               output_rect, gfx::RectF(), WebKit::WebFilterOperations(),
                skia::RefPtr<SkImageFilter>(), WebKit::WebFilterOperations());
-  quadSink.Append(quad.PassAs<DrawQuad>(), &data);
+  quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
 }
 
 }  // namespace cc
diff --git a/cc/test/render_pass_test_utils.h b/cc/test/render_pass_test_utils.h
index 86715c0..5c2f676 100644
--- a/cc/test/render_pass_test_utils.h
+++ b/cc/test/render_pass_test_utils.h
@@ -21,25 +21,25 @@ class TestRenderPass;
 
 // Adds a new render pass with the provided properties to the given
 // render pass list.
-TestRenderPass* addRenderPass(
-    RenderPassList& passList,
+TestRenderPass* AddRenderPass(
+    RenderPassList& pass_list,
     RenderPass::Id id,
-    const gfx::Rect& outputRect,
-    const gfx::Transform& rootTransform);
+    gfx::Rect output_rect,
+    const gfx::Transform& root_transform);
 
 // Adds a solid quad to a given render pass.
-SolidColorDrawQuad* addQuad(TestRenderPass* pass,
-                            const gfx::Rect& rect,
+SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
+                            gfx::Rect rect,
                             SkColor color);
 
 // Adds a solid quad to a given render pass and sets is_clipped=true.
-SolidColorDrawQuad* addClippedQuad(TestRenderPass* pass,
-                                   const gfx::Rect& rect,
+SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
+                                   gfx::Rect rect,
                                    SkColor color);
 
 // Adds a render pass quad to an existing render pass.
-void addRenderPassQuad(TestRenderPass* toPass,
-                       TestRenderPass* contributingPass);
+void AddRenderPassQuad(TestRenderPass* to_pass,
+                       TestRenderPass* contributing_pass);
 
 }  // namespace cc
 
diff --git a/cc/test/tiled_layer_test_common.h b/cc/test/tiled_layer_test_common.h
index 3012fd5..11666d3 100644
--- a/cc/test/tiled_layer_test_common.h
+++ b/cc/test/tiled_layer_test_common.h
@@ -119,7 +119,7 @@ class FakeTiledLayer : public TiledLayer {
   FakeLayerUpdater* fake_layer_updater() { return fake_updater_.get(); }
   gfx::RectF update_rect() { return update_rect_; }
 
-  // Simulate calcDrawProperties.
+  // Simulate CalcDrawProperties.
   void UpdateContentsScale(float ideal_contents_scale);
 
  protected:
diff --git a/cc/trees/damage_tracker.cc b/cc/trees/damage_tracker.cc
index e0a505f..698f9643 100644
--- a/cc/trees/damage_tracker.cc
+++ b/cc/trees/damage_tracker.cc
@@ -186,9 +186,9 @@ gfx::RectF DamageTracker::TrackDamageFromActiveLayers(
     int target_surface_layer_id) {
   gfx::RectF damage_rect = gfx::RectF();
 
-  for (unsigned layerIndex = 0; layerIndex < layer_list.size(); ++layerIndex) {
+  for (size_t layer_index = 0; layer_index < layer_list.size(); ++layer_index) {
     // Visit layers in back-to-front order.
-    LayerImpl* layer = layer_list[layerIndex];
+    LayerImpl* layer = layer_list[layer_index];
 
     if (LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerImpl>(
             layer, target_surface_layer_id))
@@ -263,9 +263,9 @@ void DamageTracker::ExtendDamageForLayer(LayerImpl* layer,
   // Property changes take priority over update rects.
   //
   // This method is called when we want to consider how a layer contributes to
-  // its targetRenderSurface, even if that layer owns the targetRenderSurface
-  // itself. To consider how a layer's targetSurface contributes to the
-  // ancestorSurface, ExtendDamageForRenderSurface() must be called instead.
+  // its target RenderSurface, even if that layer owns the target RenderSurface
+  // itself. To consider how a layer's target surface contributes to the
+  // ancestor surface, ExtendDamageForRenderSurface() must be called instead.
 
   bool layer_is_new = false;
   gfx::RectF old_rect_in_target_space =
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 561210f..610c68f 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -56,7 +56,7 @@ void EmulateDrawingOneFrame(LayerImpl* root) {
   // This emulates only steps that are relevant to testing the damage tracker:
   //   1. computing the render passes and layerlists
   //   2. updating all damage trackers in the correct order
-  //   3. resetting all update_rects and propertyChanged flags for all layers
+  //   3. resetting all update_rects and property_changed flags for all layers
   //      and surfaces.
 
   std::vector<LayerImpl*> render_surface_layer_list;
@@ -138,10 +138,10 @@ class DamageTrackerTest : public testing::Test {
     child1->SetAnchorPoint(gfx::PointF());
     child1->SetBounds(gfx::Size(30, 30));
     child1->SetContentBounds(gfx::Size(30, 30));
-    // With a child that drawsContent, opacity will cause the layer to create
-    // its own renderSurface. This layer does not draw, but is intended to
-    // create its own renderSurface. TODO: setting opacity and
-    // forceRenderSurface may be redundant here.
+    // With a child that draws_content, opacity will cause the layer to create
+    // its own RenderSurface. This layer does not draw, but is intended to
+    // create its own RenderSurface. TODO: setting opacity and
+    // ForceRenderSurface may be redundant here.
     child1->SetOpacity(0.5f);
     child1->SetDrawsContent(false);
     child1->SetForceRenderSurface(true);
@@ -231,7 +231,7 @@ TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) {
   EXPECT_EQ(3u, root->render_surface()->layer_list().size());
   EXPECT_EQ(2u, child1->render_surface()->layer_list().size());
 
-  // The render surface for child1 only has a contentRect that encloses
+  // The render surface for child1 only has a content_rect that encloses
   // grand_child1 and grand_child2, because child1 does not draw content.
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 16.f, 18.f), child_damage_rect);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 500.f, 500.f), root_damage_rect);
@@ -545,7 +545,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) {
                              0);
   EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
 
-  // CASE 3: Setting this update rect outside the blurred contentBounds of the
+  // CASE 3: Setting this update rect outside the blurred content_bounds of the
   //         blurred child1 will not cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
   root->set_update_rect(gfx::RectF(30.f, 30.f, 2.f, 2.f));
@@ -560,8 +560,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) {
 
   EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
 
-  // CASE 4: Setting this update rect inside the blurred contentBounds but
-  //         outside the original contentBounds of the blurred child1 will
+  // CASE 4: Setting this update rect inside the blurred content_bounds but
+  //         outside the original content_bounds of the blurred child1 will
   //         cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
   root->set_update_rect(gfx::RectF(99.f, 99.f, 1.f, 1.f));
@@ -805,13 +805,13 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromDescendantLayer) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
   // An ancestor/owning layer changes that affects the position/transform of
-  // the render surface. Note that in this case, the layerPropertyChanged flag
+  // the render surface. Note that in this case, the layer_property_changed flag
   // already propagates to the subtree (tested in LayerImpltest), which damages
   // 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 scissorRect per renderSurface. In that case,
+  //        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.
@@ -950,7 +950,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
 
   // For this test case, we modify grand_child2, and add grand_child3 to extend
   // the bounds of child1's surface. This way, we can test reflection changes
-  // without changing contentBounds of the surface.
+  // without changing content_bounds of the surface.
   grand_child2->SetPosition(gfx::PointF(180.f, 180.f));
   {
     scoped_ptr<LayerImpl> grand_child3 =
@@ -1211,7 +1211,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithAnchor) {
   LayerImpl* child1 = root->children()[0];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  // Verify that the correct replicaOriginTransform is used for the replicaMask
+  // Verify that the correct replica_origin_transform is used for the
+  // replica_mask.
   ClearDamageForAllSurfaces(root.get());
 
   // This is not actually the anchor point being tested, but by convention its
@@ -1250,7 +1251,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithAnchor) {
   // Sanity check that the appropriate render surfaces were created
   ASSERT_TRUE(grand_child1->render_surface());
 
-  // A property change on the replicaMask should damage the reflected region on
+  // A property change on the replica_mask should damage the reflected region on
   // the target surface.
   ClearDamageForAllSurfaces(root.get());
   replica_mask_layer->SetStackingOrderChanged(true);
@@ -1290,7 +1291,7 @@ TEST_F(DamageTrackerTest, VerifyDamageWhenForcedFullDamage) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
   // Though it should never happen, its a good idea to verify that the damage
-  // tracker does not crash when it receives an empty layerList.
+  // tracker does not crash when it receives an empty layer_list.
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.active_tree(), 1);
   root->CreateRenderSurface();
diff --git a/cc/trees/layer_sorter.cc b/cc/trees/layer_sorter.cc
index 16b75fa..ffeb04a 100644
--- a/cc/trees/layer_sorter.cc
+++ b/cc/trees/layer_sorter.cc
@@ -188,11 +188,11 @@ LayerShape::LayerShape(float width,
 
   // Compute the projection of the layer quad onto the z = 0 plane.
 
-  gfx::PointF clippedQuad[8];
+  gfx::PointF clipped_quad[8];
   int num_vertices_in_clipped_quad;
   MathUtil::MapClippedQuad(draw_transform,
                            layer_quad,
-                           clippedQuad,
+                           clipped_quad,
                            num_vertices_in_clipped_quad);
 
   if (num_vertices_in_clipped_quad < 3) {
@@ -201,7 +201,7 @@ LayerShape::LayerShape(float width,
   }
 
   projected_bounds =
-      MathUtil::ComputeEnclosingRectOfVertices(clippedQuad,
+      MathUtil::ComputeEnclosingRectOfVertices(clipped_quad,
                                                num_vertices_in_clipped_quad);
 
   // NOTE: it will require very significant refactoring and overhead to deal
@@ -209,14 +209,14 @@ LayerShape::LayerShape(float width,
   // layer sorting it is equally correct to take a subsection of the polygon
   // that can be made into a quad. This will only be incorrect in the case of
   // intersecting layers, which are not supported yet anyway.
-  projected_quad.set_p1(clippedQuad[0]);
-  projected_quad.set_p2(clippedQuad[1]);
-  projected_quad.set_p3(clippedQuad[2]);
+  projected_quad.set_p1(clipped_quad[0]);
+  projected_quad.set_p2(clipped_quad[1]);
+  projected_quad.set_p3(clipped_quad[2]);
   if (num_vertices_in_clipped_quad >= 4) {
-    projected_quad.set_p4(clippedQuad[3]);
+    projected_quad.set_p4(clipped_quad[3]);
   } else {
     // This will be a degenerate quad that is actually a triangle.
-    projected_quad.set_p4(clippedQuad[2]);
+    projected_quad.set_p4(clipped_quad[2]);
   }
 
   // Compute the normal of the layer's plane.
@@ -298,7 +298,7 @@ void LayerSorter::CreateGraphNodes(LayerList::iterator first,
 
 void LayerSorter::CreateGraphEdges() {
   DVLOG(2) << "Edges:";
-  // Fraction of the total zRange below which z differences
+  // Fraction of the total z_range below which z differences
   // are not considered reliable.
   const float z_threshold_factor = 0.01f;
   float z_threshold = z_range_ * z_threshold_factor;
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 5ef698a..20ba6e4 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -701,7 +701,7 @@ void LayerTreeHost::UpdateLayers(Layer* root_layer,
 
     UpdateHudLayer();
 
-    TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::calcDrawProps");
+    TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
     LayerTreeHostCommon::CalculateDrawProperties(
         root_layer,
         device_viewport_size(),
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 27aeb70..7625f4e 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -157,7 +157,7 @@ static gfx::Rect CalculateVisibleContentRect(
 
   if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) {
     // In this case the target surface does clip layers that contribute to
-    // it. So, we have to convert the current surface's clipRect from its
+    // it. So, we have to convert the current surface's clip rect from its
     // ancestor surface space to the current (descendant) surface
     // space. This conversion is done outside this function so that it can
     // be cached instead of computing it redundantly for every layer.
@@ -198,8 +198,8 @@ static bool LayerShouldBeSkipped(LayerType* layer) {
   //
   // Some additional conditions need to be computed at a later point after the
   // recursion is finished.
-  //   - the intersection of render surface content and layer clipRect is empty
-  //   - the visibleContentRect is empty
+  //   - the intersection of render_surface content and layer clip_rect is empty
+  //   - the visible_content_rect is empty
   //
   // Note, if the layer should not have been drawn due to being fully
   // transparent, we would have skipped the entire subtree and never made it
@@ -244,7 +244,7 @@ static inline bool SubtreeShouldBeSkipped(Layer* layer) {
 }
 
 // Called on each layer that could be drawn after all information from
-// calcDrawProperties has been updated on that layer.  May have some false
+// CalcDrawProperties has been updated on that layer.  May have some false
 // positives (e.g. layers get this called on them but don't actually get drawn).
 static inline void UpdateTilePrioritiesForLayer(LayerImpl* layer) {
   layer->UpdateTilePriorities();
@@ -352,10 +352,10 @@ gfx::Transform ComputeScrollCompensationForThisLayer(
   //           -- this transform is the "partial_layer_origin_transform" =
   //           (parent_matrix * scale(layer->pageScaleDelta()));
   //
-  // These steps create a matrix that both start and end in targetSurfaceSpace.
-  // So this matrix can pre-multiply any fixed-position layer's draw_transform
-  // to undo the scroll_deltas -- as long as that fixed position layer is fixed
-  // onto the same render_target as this scrolling_layer.
+  // These steps create a matrix that both start and end in target surface
+  // space. So this matrix can pre-multiply any fixed-position layer's
+  // draw_transform to undo the scroll_deltas -- as long as that fixed position
+  // layer is fixed onto the same render_target as this scrolling_layer.
   //
 
   gfx::Transform partial_layer_origin_transform = parent_matrix;
@@ -430,7 +430,7 @@ gfx::Transform ComputeScrollCompensationMatrixForChildren(
     next_scroll_compensation_matrix = current_scroll_compensation_matrix;
 
   // If the current layer has a non-zero scroll_delta, then we should compute
-  // its local scrollCompensation and accumulate it to the
+  // its local scroll compensation and accumulate it to the
   // next_scroll_compensation_matrix.
   if (!layer->scroll_delta().IsZero()) {
     gfx::Transform scroll_compensation_for_this_layer =
@@ -441,7 +441,7 @@ gfx::Transform ComputeScrollCompensationMatrixForChildren(
 
   // If the layer created its own render_surface, we have to adjust
   // next_scroll_compensation_matrix.  The adjustment allows us to continue
-  // using the scrollCompensation on the next surface.
+  // using the scroll compensation on the next surface.
   //  Step 1 (right-most in the math): transform from the new surface to the
   //  original ancestor surface
   //  Step 2: apply the scroll compensation
@@ -621,7 +621,7 @@ static void RoundTranslationComponents(gfx::Transform* transform) {
 }
 
 // Recursively walks the layer tree starting at the given node and computes all
-// the necessary transformations, clipRects, render surfaces, etc.
+// the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType, typename LayerList, typename RenderSurfaceType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
@@ -681,15 +681,15 @@ static void CalculateDrawPropertiesInternal(
   //        M[sublayer] is the layer's sublayer transform (also applied at the
   //        layer's anchor point)
   //
-  //        S[layer2content] is the ratio of a layer's ContentBounds() to its
+  //        S[layer2content] is the ratio of a layer's content_bounds() to its
   //        Bounds().
   //
   //    Some composite transforms can help in understanding the sequence of
   //    transforms:
-  //        compositeLayerTransform = Tr[origin2anchor] * M[layer] *
+  //        composite_layer_transform = Tr[origin2anchor] * M[layer] *
   //        Tr[origin2anchor].inverse()
   //
-  //        compositeSublayerTransform = Tr[origin2anchor] * M[sublayer] *
+  //        composite_sublayer_transform = Tr[origin2anchor] * M[sublayer] *
   //        Tr[origin2anchor].inverse()
   //
   // 4. When a layer (or render surface) is drawn, it is drawn into a "target
@@ -704,17 +704,17 @@ static void CalculateDrawPropertiesInternal(
   // Using these definitions, then:
   //
   // The draw transform for the layer is:
-  //        M[draw] = M[parent] * Tr[origin] * compositeLayerTransform *
-  //            S[layer2content] = M[parent] * Tr[layer->Position() + anchor] *
+  //        M[draw] = M[parent] * Tr[origin] * composite_layer_transform *
+  //            S[layer2content] = M[parent] * Tr[layer->position() + anchor] *
   //            M[layer] * Tr[anchor2origin] * S[layer2content]
   //
   //        Interpreting the math left-to-right, this transforms from the
   //        layer's render surface to the origin of the layer in content space.
   //
   // The screen space transform is:
-  //        M[screenspace] = M[root] * Tr[origin] * compositeLayerTransform *
+  //        M[screenspace] = M[root] * Tr[origin] * composite_layer_transform *
   //            S[layer2content]
-  //                       = M[root] * Tr[layer->Position() + anchor] * M[layer]
+  //                       = M[root] * Tr[layer->position() + anchor] * M[layer]
   //                           * Tr[anchor2origin] * S[layer2content]
   //
   //        Interpreting the math left-to-right, this transforms from the root
@@ -724,10 +724,10 @@ static void CalculateDrawPropertiesInternal(
   // The transform hierarchy that is passed on to children (i.e. the child's
   // parent_matrix) is:
   //        M[parent]_for_child = M[parent] * Tr[origin] *
-  //            compositeLayerTransform * compositeSublayerTransform
-  //                            = M[parent] * Tr[layer->Position() + anchor] *
-  //                                M[layer] * Tr[anchor2origin] *
-  //                                compositeSublayerTransform
+  //            composite_layer_transform * composite_sublayer_transform
+  //                            = M[parent] * Tr[layer->position() + anchor] *
+  //                              M[layer] * Tr[anchor2origin] *
+  //                              composite_sublayer_transform
   //
   //        and a similar matrix for the full hierarchy with respect to the
   //        root.
@@ -755,19 +755,19 @@ static void CalculateDrawPropertiesInternal(
   //
   // The replica draw transform to its target surface origin is:
   //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] *
-  //            Tr[replica->Position() + replica->anchor()] * Tr[replica] *
+  //            Tr[replica->position() + replica->anchor()] * Tr[replica] *
   //            Tr[origin2anchor].inverse() * S[contents_scale].inverse()
   //
   // The replica draw transform to the root (screen space) origin is:
-  //        M[replica2root] = M[surface2root] * Tr[replica->Position()] *
+  //        M[replica2root] = M[surface2root] * Tr[replica->position()] *
   //            Tr[replica] * Tr[origin2anchor].inverse()
   //
 
-  // If we early-exit anywhere in this function, the drawableContentRect of this
+  // If we early-exit anywhere in this function, the drawable_content_rect of this
   // subtree should be considered empty.
   *drawable_content_rect_of_subtree = gfx::Rect();
 
-  // The root layer cannot skip calcDrawProperties.
+  // The root layer cannot skip CalcDrawProperties.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer))
     return;
 
@@ -782,8 +782,8 @@ static void CalculateDrawPropertiesInternal(
   bool subtree_should_be_clipped = false;
 
   // This value is cached on the stack so that we don't have to inverse-project
-  // the surface's clipRect redundantly for every layer. This value is the
-  // same as the surface's clipRect, except that instead of being described
+  // the surface's clip rect redundantly for every layer. This value is the
+  // same as the surface's clip rect, except that instead of being described
   // in the target surface space (i.e. the ancestor surface space), it is
   // described in the current surface space.
   gfx::Rect clip_rect_for_subtree_in_descendant_space;
@@ -828,7 +828,7 @@ static void CalculateDrawPropertiesInternal(
     combined_transform.Translate(position.x(), position.y());
   }
 
-  // The layer's contentsSize is determined from the combined_transform, which
+  // The layer's contents_scale is determined from the combined_transform, which
   // then informs the layer's draw_transform.
   UpdateLayerContentsScale(layer,
                            combined_transform,
@@ -839,7 +839,7 @@ static void CalculateDrawPropertiesInternal(
   // If there is a transformation from the impl thread then it should be at
   // the start of the combined_transform, but we don't want it to affect the
   // computation of contents_scale above.
-  // Note carefully: this is Concat, not Preconcat (implTransform *
+  // Note carefully: this is Concat, not Preconcat (impl_transform *
   // combined_transform).
   combined_transform.ConcatTransform(layer->impl_transform());
 
@@ -868,8 +868,8 @@ static void CalculateDrawPropertiesInternal(
   layer_draw_properties.target_space_transform.Scale
       (1.f / layer->contents_scale_x(), 1.f / layer->contents_scale_y());
 
-  // layerScreenSpaceTransform represents the transform between root layer's
-  // "screen space" and local content space.
+  // The layer's screen_space_transform represents the transform between root
+  // layer's "screen space" and local content space.
   layer_draw_properties.screen_space_transform = full_hierarchy_matrix;
   if (!layer->preserves_3d())
     layer_draw_properties.screen_space_transform.FlattenTo2d();
@@ -963,7 +963,7 @@ static void CalculateDrawPropertiesInternal(
 
     // The new render_surface here will correctly clip the entire subtree. So,
     // we do not need to continue propagating the clipping state further down
-    // the tree. This way, we can avoid transforming clipRects from ancestor
+    // the tree. This way, we can avoid transforming clip rects from ancestor
     // target surface space to current target surface space that could cause
     // more w < 0 headaches.
     subtree_should_be_clipped = false;
@@ -990,7 +990,7 @@ static void CalculateDrawPropertiesInternal(
     if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
       nearest_ancestor_that_moves_pixels = render_surface;
 
-    // The render surface clipRect is expressed in the space where this surface
+    // The render surface clip rect is expressed in the space where this surface
     // draws, i.e. the same space as clip_rect_from_ancestor.
     render_surface->SetIsClipped(ancestor_clips_subtree);
     if (ancestor_clips_subtree) {
@@ -1044,7 +1044,7 @@ static void CalculateDrawPropertiesInternal(
     if (ancestor_clips_subtree)
       clip_rect_for_subtree = clip_rect_from_ancestor;
 
-    // The surface's cached clipRect value propagates regardless of what
+    // The surface's cached clip rect value propagates regardless of what
     // clipping goes on between layers here.
     clip_rect_for_subtree_in_descendant_space =
         clip_rect_from_ancestor_in_descendant_space;
@@ -1135,8 +1135,8 @@ static void CalculateDrawPropertiesInternal(
     return;
   }
 
-  // Compute the total drawableContentRect for this subtree (the rect is in
-  // targetSurface space).
+  // Compute the total drawable_content_rect for this subtree (the rect is in
+  // target surface space).
   gfx::Rect local_drawable_content_rect_of_subtree =
       accumulated_drawable_content_rect_of_children;
   if (layer->DrawsContent())
@@ -1144,7 +1144,7 @@ static void CalculateDrawPropertiesInternal(
   if (subtree_should_be_clipped)
     local_drawable_content_rect_of_subtree.Intersect(clip_rect_for_subtree);
 
-  // Compute the layer's drawable content rect (the rect is in targetSurface
+  // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
   if (subtree_should_be_clipped) {
@@ -1153,14 +1153,14 @@ static void CalculateDrawPropertiesInternal(
   }
 
   // Tell the layer the rect that is clipped by. In theory we could use a
-  // tighter clipRect here (drawableContentRect), but that actually does not
+  // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance.
   layer_draw_properties.is_clipped = subtree_should_be_clipped;
   if (subtree_should_be_clipped) {
     layer_draw_properties.clip_rect = clip_rect_for_subtree;
   } else {
-    // Initialize the clipRect to a safe value that will not clip the
+    // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
@@ -1299,8 +1299,8 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   std::vector<scoped_refptr<Layer> > dummy_layer_list;
 
-  // The root layer's render_surface should receive the deviceViewport as the
-  // initial clipRect.
+  // The root layer's render_surface should receive the device viewport as the
+  // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
   bool update_tile_priorities = false;
@@ -1332,7 +1332,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   // The dummy layer list should not have been used.
   DCHECK_EQ(dummy_layer_list.size(), 0);
   // A root layer render_surface should always exist after
-  // calculateDrawProperties.
+  // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
@@ -1352,8 +1352,8 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   std::vector<LayerImpl*> dummy_layer_list;
   LayerSorter layer_sorter;
 
-  // The root layer's render_surface should receive the deviceViewport as the
-  // initial clipRect.
+  // The root layer's render_surface should receive the device viewport as the
+  // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
 
@@ -1385,7 +1385,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   // The dummy layer list should not have been used.
   DCHECK_EQ(dummy_layer_list.size(), 0);
   // A root layer render_surface should always exist after
-  // calculateDrawProperties.
+  // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index 7644c91..84ad8c1 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -98,8 +98,8 @@ bool LayerTreeHostCommon::RenderSurfaceContributesToTarget(
   // A layer will either contribute its own content, or its render surface's
   // content, to the target surface. The layer contributes its surface's content
   // when both the following are true:
-  //  (1) The layer actually has a renderSurface, and
-  //  (2) The layer's renderSurface is not the same as the targetSurface.
+  //  (1) The layer actually has a render surface, and
+  //  (2) The layer's render surface is not the same as the target surface.
   //
   // Otherwise, the layer just contributes itself to the target surface.
 
@@ -131,12 +131,12 @@ template <class Function, typename LayerType>
 void LayerTreeHostCommon::CallFunctionForSubtree(LayerType* root_layer) {
   Function()(root_layer);
 
-  if (LayerType* maskLayer = root_layer->mask_layer())
-    Function()(maskLayer);
-  if (LayerType* replicaLayer = root_layer->replica_layer()) {
-    Function()(replicaLayer);
-    if (LayerType* maskLayer = replicaLayer->mask_layer())
-      Function()(maskLayer);
+  if (LayerType* mask_layer = root_layer->mask_layer())
+    Function()(mask_layer);
+  if (LayerType* replica_layer = root_layer->replica_layer()) {
+    Function()(replica_layer);
+    if (LayerType* mask_layer = replica_layer->mask_layer())
+      Function()(mask_layer);
   }
 
   for (size_t i = 0; i < root_layer->children().size(); ++i) {
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index f2fb51c..36659f5 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -710,9 +710,9 @@ static void RemoveRenderPassesRecursive(RenderPass::Id remove_render_pass_id,
   // Now follow up for all RenderPass quads and remove their RenderPasses
   // recursively.
   const QuadList& quad_list = removed_pass->quad_list;
-  QuadList::constBackToFrontIterator quad_list_iterator =
-      quad_list.backToFrontBegin();
-  for (; quad_list_iterator != quad_list.backToFrontEnd();
+  QuadList::ConstBackToFrontIterator quad_list_iterator =
+      quad_list.BackToFrontBegin();
+  for (; quad_list_iterator != quad_list.BackToFrontEnd();
        ++quad_list_iterator) {
     DrawQuad* current_quad = (*quad_list_iterator);
     if (current_quad->material != DrawQuad::RENDER_PASS)
@@ -750,9 +750,9 @@ bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
 
   // If any quad or RenderPass draws into this RenderPass, then keep it.
   const QuadList& quad_list = render_pass->quad_list;
-  for (QuadList::constBackToFrontIterator quad_list_iterator =
-           quad_list.backToFrontBegin();
-       quad_list_iterator != quad_list.backToFrontEnd();
+  for (QuadList::ConstBackToFrontIterator quad_list_iterator =
+           quad_list.BackToFrontBegin();
+       quad_list_iterator != quad_list.BackToFrontEnd();
        ++quad_list_iterator) {
     DrawQuad* current_quad = *quad_list_iterator;
 
@@ -784,10 +784,10 @@ void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
        it = culler.RenderPassListNext(it)) {
     const RenderPass* current_pass = frame->render_passes[it];
     const QuadList& quad_list = current_pass->quad_list;
-    QuadList::constBackToFrontIterator quad_list_iterator =
-        quad_list.backToFrontBegin();
+    QuadList::ConstBackToFrontIterator quad_list_iterator =
+        quad_list.BackToFrontBegin();
 
-    for (; quad_list_iterator != quad_list.backToFrontEnd();
+    for (; quad_list_iterator != quad_list.BackToFrontEnd();
          ++quad_list_iterator) {
       DrawQuad* current_quad = *quad_list_iterator;
 
@@ -1041,10 +1041,10 @@ gfx::SizeF LayerTreeHostImpl::VisibleViewportSize() const {
       clip_layer->masks_to_bounds())
     dip_size = clip_layer->bounds();
 
-  float topOffset =
+  float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
   return gfx::SizeF(dip_size.width(),
-                    dip_size.height() - topOffset - overdraw_bottom_height_);
+                    dip_size.height() - top_offset - overdraw_bottom_height_);
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::Settings() const {
@@ -1359,7 +1359,7 @@ bool LayerTreeHostImpl::EnsureRenderSurfaceLayerList() {
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     gfx::Point viewport_point, InputHandlerClient::ScrollInputType type) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
+  TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   if (top_controls_manager_)
     top_controls_manager_->ScrollBegin();
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 10fb24a..e69291d 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -139,7 +139,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
   void SetAnticipatedDrawTime(base::TimeTicks time);
 
   // Returns false if problems occured preparing the frame, and we should try
-  // to avoid displaying the frame. If prepareToDraw is called, DidDrawAllLayers
+  // to avoid displaying the frame. If PrepareToDraw is called, DidDrawAllLayers
   // must also be called, regardless of whether DrawLayers is called between the
   // two.
   virtual bool PrepareToDraw(FrameData* frame);
@@ -250,7 +250,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
   void SendManagedMemoryStats(
       size_t memory_visible_bytes,
       size_t memory_visible_and_nearby_bytes,
-      size_t memoryUseBytes);
+      size_t memory_use_bytes);
 
   FrameRateCounter* fps_counter() {
     return fps_counter_.get();
@@ -365,17 +365,17 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
   void AnimateTopControls(base::TimeTicks monotonic_time);
 
   gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
-      LayerImpl* layerImpl,
-      float scaleFromViewportToScreenSpace,
-      gfx::PointF viewportPoint,
-      gfx::Vector2dF viewportDelta);
+      LayerImpl* layer_impl,
+      float scale_from_viewport_to_screen_space,
+      gfx::PointF viewport_point,
+      gfx::Vector2dF viewport_delta);
 
   void UpdateMaxScrollOffset();
   void TrackDamageForAllSurfaces(LayerImpl* root_draw_layer,
                                  const LayerList& render_surface_layer_list);
 
   // Returns false if the frame should not be displayed. This function should
-  // only be called from prepareToDraw, as didDrawAllLayers must be called
+  // only be called from PrepareToDraw, as DidDrawAllLayers must be called
   // if this helper function is called.
   bool CalculateRenderPasses(FrameData* frame);
   void SetBackgroundTickingEnabled(bool enabled);
diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc
index 72abb15..8be65f1 100644
--- a/cc/trees/layer_tree_host_unittest_occlusion.cc
+++ b/cc/trees/layer_tree_host_unittest_occlusion.cc
@@ -42,7 +42,7 @@ class TestLayer : public Layer {
   TestLayer() : Layer() {
     SetIsDrawable(true);
   }
-  virtual ~TestLayer() { }
+  virtual ~TestLayer() {}
 
   Region occlusion_;
   Region expected_occlusion_;
@@ -111,8 +111,8 @@ class LayerTreeHostOcclusionTestOcclusionSurfaceClipping :
     public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() OVERRIDE {
-    // The child layer is a surface and the grandChild is opaque, but clipped to
-    // the child and root
+    // The child layer is a surface and the grand_child is opaque, but clipped
+    // to the child and root
     SetLayerPropertiesForTesting(
         root_.get(), NULL, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
@@ -342,10 +342,10 @@ class LayerTreeHostOcclusionTestOcclusionOpacityFilter :
     public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() OVERRIDE {
-    gfx::Transform childTransform;
-    childTransform.Translate(250.0, 250.0);
-    childTransform.Rotate(90.0);
-    childTransform.Translate(-250.0, -250.0);
+    gfx::Transform child_transform;
+    child_transform.Translate(250.0, 250.0);
+    child_transform.Rotate(90.0);
+    child_transform.Translate(-250.0, -250.0);
 
     WebKit::WebFilterOperations filters;
     filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5));
@@ -357,7 +357,7 @@ class LayerTreeHostOcclusionTestOcclusionOpacityFilter :
         root_.get(), NULL, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
-        child_.get(), root_.get(), childTransform,
+        child_.get(), root_.get(), child_transform,
         gfx::PointF(30.f, 30.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
@@ -386,10 +386,10 @@ class LayerTreeHostOcclusionTestOcclusionBlurFilter :
     public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() OVERRIDE {
-    gfx::Transform childTransform;
-    childTransform.Translate(250.0, 250.0);
-    childTransform.Rotate(90.0);
-    childTransform.Translate(-250.0, -250.0);
+    gfx::Transform child_transform;
+    child_transform.Translate(250.0, 250.0);
+    child_transform.Rotate(90.0);
+    child_transform.Translate(-250.0, -250.0);
 
     WebKit::WebFilterOperations filters;
     filters.append(WebKit::WebFilterOperation::createBlurFilter(10));
@@ -401,7 +401,7 @@ class LayerTreeHostOcclusionTestOcclusionBlurFilter :
         root_.get(), NULL, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
-        child_.get(), root_.get(), childTransform,
+        child_.get(), root_.get(), child_transform,
         gfx::PointF(30.f, 30.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index dae8ae8..14b225f 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -566,7 +566,7 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
           EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
           PostSetNeedsCommitToMainThread();
 
-          // commitCompleteOnThread will trigger this function again
+          // CommitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           can_activate_ = true;
@@ -660,6 +660,5 @@ class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollZeroMaxScrollOffset)
 
-
 }  // namespace
 }  // namespace cc
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 95d2291..10f5ad6 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -278,7 +278,7 @@ void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
-  // For maxTextureSize.
+  // For max_texture_size.
   if (!layer_tree_host_impl_->renderer())
       return;
 
@@ -371,10 +371,10 @@ void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   layer_id_map_.erase(layer->id());
 }
 
-void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pendingTree) {
+void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pending_tree) {
   int id = currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
-  pendingTree->SetCurrentlyScrollingLayer(
-      LayerTreeHostCommon::FindLayerInSubtree(pendingTree->root_layer(), id));
+  pending_tree->SetCurrentlyScrollingLayer(
+      LayerTreeHostCommon::FindLayerInSubtree(pending_tree->root_layer(), id));
 }
 
 static void DidBecomeActiveRecursive(LayerImpl* layer) {
@@ -430,7 +430,7 @@ const LayerTreeSettings& LayerTreeImpl::settings() const {
   return layer_tree_host_impl_->settings();
 }
 
-const RendererCapabilities& LayerTreeImpl::rendererCapabilities() const {
+const RendererCapabilities& LayerTreeImpl::GetRendererCapabilities() const {
   return layer_tree_host_impl_->GetRendererCapabilities();
 }
 
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 0a78add..1f89d16 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -42,8 +42,8 @@ class CC_EXPORT LayerTreeImpl {
  public:
   typedef std::vector<LayerImpl*> LayerList;
 
-  static scoped_ptr<LayerTreeImpl> create(LayerTreeHostImpl* layer_tree_host_impl)
-  {
+  static scoped_ptr<LayerTreeImpl> create(
+      LayerTreeHostImpl* layer_tree_host_impl) {
     return make_scoped_ptr(new LayerTreeImpl(layer_tree_host_impl));
   }
   virtual ~LayerTreeImpl();
@@ -51,7 +51,7 @@ class CC_EXPORT LayerTreeImpl {
   // Methods called by the layer tree that pass-through or access LTHI.
   // ---------------------------------------------------------------------------
   const LayerTreeSettings& settings() const;
-  const RendererCapabilities& rendererCapabilities() const;
+  const RendererCapabilities& GetRendererCapabilities() const;
   OutputSurface* output_surface() const;
   ResourceProvider* resource_provider() const;
   TileManager* tile_manager() const;
@@ -173,7 +173,7 @@ class CC_EXPORT LayerTreeImpl {
 
   AnimationRegistrar* animationRegistrar() const;
 
-  void PushPersistedState(LayerTreeImpl* pendingTree);
+  void PushPersistedState(LayerTreeImpl* pending_tree);
 
   void DidBecomeActive();
 
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index d81232f9..98ad442 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -253,7 +253,7 @@ static void ReduceOcclusionBelowSurface(LayerType* contributing_layer,
   contributing_layer->background_filters().getOutsets(
       outset_top, outset_right, outset_bottom, outset_left);
 
-  // The filter can move pixels from outside of the clip, so allow affectedArea
+  // The filter can move pixels from outside of the clip, so allow affected_area
   // to expand outside the clip.
   affected_area_in_target.Inset(
       -outset_left, -outset_top, -outset_right, -outset_bottom);
@@ -426,12 +426,12 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::
       ScreenSpaceClipRectInTargetSurface(
           layer->render_target()->render_surface(), screen_space_clip_rect_));
 
-  for (Region::Iterator opaqueContentRects(opaque_contents);
-       opaqueContentRects.has_rect();
-       opaqueContentRects.next()) {
+  for (Region::Iterator opaque_content_rects(opaque_contents);
+       opaque_content_rects.has_rect();
+       opaque_content_rects.next()) {
     gfx::QuadF transformed_quad = MathUtil::MapQuad(
         layer->draw_transform(),
-        gfx::QuadF(opaqueContentRects.rect()),
+        gfx::QuadF(opaque_content_rects.rect()),
         &clipped);
     gfx::Rect transformed_rect =
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
@@ -461,14 +461,14 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::
 
   Region non_opaque_contents =
       SubtractRegions(gfx::Rect(layer->content_bounds()), opaque_contents);
-  for (Region::Iterator nonOpaqueContentRects(non_opaque_contents);
-       nonOpaqueContentRects.has_rect();
-       nonOpaqueContentRects.next()) {
-    // We've already checked for clipping in the mapQuad call above, these calls
+  for (Region::Iterator non_opaque_content_rects(non_opaque_contents);
+       non_opaque_content_rects.has_rect();
+       non_opaque_content_rects.next()) {
+    // We've already checked for clipping in the MapQuad call above, these calls
     // should not clip anything further.
     gfx::Rect transformed_rect = gfx::ToEnclosedRect(
         MathUtil::MapClippedRect(layer->draw_transform(),
-                                 gfx::RectF(nonOpaqueContentRects.rect())));
+                                 gfx::RectF(non_opaque_content_rects.rect())));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.IsEmpty())
       continue;
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 6972313..f69e4b3 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -106,7 +106,7 @@ class TestOcclusionTrackerWithClip :
                           has_occlusion_from_outside_target_surface);
   }
   // Gives an unoccluded sub-rect of |content_rect| in the content space of the
-  // layer. Simple wrapper around unoccludedContentRect.
+  // layer. Simple wrapper around UnoccludedContentRect.
   gfx::Rect UnoccludedLayerContentRect(const LayerType* layer,
                                        gfx::Rect content_rect) const {
     bool temp;
@@ -3570,7 +3570,7 @@ class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter :
 
     // These layers occlude pixels directly beside the filtered_surface. Because
     // filtered surface blends pixels in a radius, it will need to see some of
-    // the pixels (up to radius far) underneath the occludingLayers.
+    // the pixels (up to radius far) underneath the occluding layers.
     this->VisitLayer(occluding_layer5, occlusion);
     this->VisitLayer(occluding_layer4, occlusion);
     this->VisitLayer(occluding_layer3, occlusion);
@@ -3859,7 +3859,7 @@ class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip :
 
     // These layers occlude pixels directly beside the filtered_surface. Because
     // filtered surface blends pixels in a radius, it will need to see some of
-    // the pixels (up to radius far) underneath the occludingLayers.
+    // the pixels (up to radius far) underneath the occluding layers.
     this->VisitLayer(occluding_layer5, occlusion);
     this->VisitLayer(occluding_layer4, occlusion);
     this->VisitLayer(occluding_layer3, occlusion);
@@ -4262,7 +4262,7 @@ class
 
     // The filter in the surface and replica are partially unoccluded. Only the
     // unoccluded parts should reduce occlusion.  This means it will push back
-    // the occlusion that touches the unoccluded part (occlusionAbove___), but
+    // the occlusion that touches the unoccluded part (occlusion_above___), but
     // it will not touch occlusion_beside____ since that is not beside the
     // unoccluded part of the surface, even though it is beside the occluded
     // part of the surface.
diff --git a/cc/trees/proxy.h b/cc/trees/proxy.h
index f0fece4..0df7f0a 100644
--- a/cc/trees/proxy.h
+++ b/cc/trees/proxy.h
@@ -84,7 +84,7 @@ class CC_EXPORT Proxy {
   virtual void SetNeedsRedraw() = 0;
 
   // Defers commits until it is reset. It is only supported when in threaded
-  // mode. It's an error to make a sync call like compositeAndReadback while
+  // mode. It's an error to make a sync call like CompositeAndReadback while
   // commits are deferred.
   virtual void SetDeferCommits(bool defer_commits) = 0;
 
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index da2046a..d2df4ff 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -52,7 +52,7 @@ SingleThreadProxy::~SingleThreadProxy() {
 }
 
 bool SingleThreadProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
-  TRACE_EVENT0("cc", "SingleThreadProxy::compositeAndReadback");
+  TRACE_EVENT0("cc", "SingleThreadProxy::CompositeAndReadback");
   DCHECK(Proxy::IsMainThread());
 
   if (!CommitAndComposite(base::TimeTicks::Now()))
@@ -95,11 +95,11 @@ bool SingleThreadProxy::IsStarted() const {
 
 bool SingleThreadProxy::InitializeOutputSurface() {
   DCHECK(Proxy::IsMainThread());
-  scoped_ptr<OutputSurface> outputSurface =
+  scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
-  if (!outputSurface.get())
+  if (!output_surface.get())
     return false;
-  output_surface_before_initialization_ = outputSurface.Pass();
+  output_surface_before_initialization_ = output_surface.Pass();
   return true;
 }
 
@@ -131,13 +131,13 @@ bool SingleThreadProxy::InitializeRenderer() {
 }
 
 bool SingleThreadProxy::RecreateOutputSurface() {
-  TRACE_EVENT0("cc", "SingleThreadProxy::recreateContext");
+  TRACE_EVENT0("cc", "SingleThreadProxy::RecreateContext");
   DCHECK(Proxy::IsMainThread());
   DCHECK(output_surface_lost_);
 
-  scoped_ptr<OutputSurface> outputSurface =
+  scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
-  if (!outputSurface.get())
+  if (!output_surface.get())
     return false;
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (created_offscreen_context_provider_) {
@@ -154,7 +154,7 @@ bool SingleThreadProxy::RecreateOutputSurface() {
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
     initialized =
-        layer_tree_host_impl_->InitializeRenderer(outputSurface.Pass());
+        layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
     if (initialized) {
       renderer_capabilities_for_main_thread_ =
           layer_tree_host_impl_->GetRendererCapabilities();
@@ -191,7 +191,7 @@ void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
-    base::TimeTicks startTime = stats_instrumentation->StartRecording();
+    base::TimeTicks start_time = stats_instrumentation->StartRecording();
 
     layer_tree_host_impl_->BeginCommit();
 
@@ -199,13 +199,13 @@ void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
         PushTexturePrioritiesToBackings();
     layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
 
-    scoped_ptr<ResourceUpdateController> updateController =
+    scoped_ptr<ResourceUpdateController> update_controller =
         ResourceUpdateController::Create(
             NULL,
             Proxy::MainThread(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
-    updateController->Finalize();
+    update_controller->Finalize();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
@@ -214,12 +214,12 @@ void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
 #ifndef NDEBUG
     // In the single-threaded case, the scroll deltas should never be
     // touched on the impl layer tree.
-    scoped_ptr<ScrollAndScaleSet> scrollInfo =
+    scoped_ptr<ScrollAndScaleSet> scroll_info =
         layer_tree_host_impl_->ProcessScrollDeltas();
-    DCHECK(!scrollInfo->scrolls.size());
+    DCHECK(!scroll_info->scrolls.size());
 #endif
 
-    base::TimeDelta duration = stats_instrumentation->EndRecording(startTime);
+    base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
     stats_instrumentation->AddCommit(duration);
   }
   layer_tree_host_->CommitComplete();
@@ -233,7 +233,7 @@ void SingleThreadProxy::SetNeedsCommit() {
 
 void SingleThreadProxy::SetNeedsRedraw() {
   // FIXME: Once we move render_widget scheduling into this class, we can
-  // treat redraw requests more efficiently than commitAndRedraw requests.
+  // treat redraw requests more efficiently than CommitAndRedraw requests.
   layer_tree_host_impl_->SetFullRootLayerDamage();
   SetNeedsCommit();
 }
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index ba621e2..264c11f 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -32,14 +32,14 @@ const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 namespace cc {
 
 scoped_ptr<Proxy> ThreadProxy::Create(LayerTreeHost* layer_tree_host,
-                                      scoped_ptr<Thread> implThread) {
+                                      scoped_ptr<Thread> impl_thread) {
   return make_scoped_ptr(
-      new ThreadProxy(layer_tree_host, implThread.Pass())).PassAs<Proxy>();
+      new ThreadProxy(layer_tree_host, impl_thread.Pass())).PassAs<Proxy>();
 }
 
 ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
-                         scoped_ptr<Thread> implThread)
-    : Proxy(implThread.Pass()),
+                         scoped_ptr<Thread> impl_thread)
+    : Proxy(impl_thread.Pass()),
       animate_requested_(false),
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
@@ -216,7 +216,7 @@ void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
 
 bool ThreadProxy::InitializeRenderer() {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeRenderer");
-  // Make a blocking call to initializeRendererOnImplThread. The results of that
+  // Make a blocking call to InitializeRendererOnImplThread. The results of that
   // call are pushed into the initialize_succeeded and capabilities local
   // variables.
   CompletionEvent completion;
@@ -255,7 +255,7 @@ bool ThreadProxy::RecreateOutputSurface() {
       return false;
   }
 
-  // Make a blocking call to recreateOutputSurfaceOnImplThread. The results of
+  // Make a blocking call to RecreateOutputSurfaceOnImplThread. The results of
   // that call are pushed into the recreate_succeeded and capabilities local
   // variables.
   CompletionEvent completion;
@@ -445,7 +445,7 @@ void ThreadProxy::SendManagedMemoryStats() {
   if (!layer_tree_host_->contents_texture_manager())
     return;
 
-  // If we are using impl-side painting, then sendManagedMemoryStats is called
+  // If we are using impl-side painting, then SendManagedMemoryStats is called
   // directly after the tile manager's manage function, and doesn't need to
   // interact with main thread's layer tree.
   if (layer_tree_host_->settings().impl_side_painting)
@@ -493,7 +493,7 @@ bool ThreadProxy::CommitRequested() const {
 
 void ThreadProxy::SetNeedsRedrawOnImplThread() {
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedrawOnImplThread");
   scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
@@ -630,14 +630,14 @@ void ThreadProxy::BeginFrame(
   }
 
   // Do not notify the impl thread of commit requests that occur during
-  // the apply/animate/layout part of the beginFrameAndCommit process since
+  // the apply/animate/layout part of the BeginFrameAndCommit process since
   // those commit requests will get painted immediately. Once we have done
   // the paint, commit_requested_ will be set to false to allow new commit
   // requests to be scheduled.
   commit_requested_ = true;
   commit_request_sent_to_impl_thread_ = true;
 
-  // On the other hand, the animationRequested flag needs to be cleared
+  // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
   // callbacks will trigger another frame.
   animate_requested_ = false;
@@ -665,7 +665,7 @@ void ThreadProxy::BeginFrame(
   }
 
   // Unlink any backings that the impl thread has evicted, so that we know to
-  // re-paint them in updateLayers.
+  // re-paint them in UpdateLayers.
   if (layer_tree_host_->contents_texture_manager()) {
     layer_tree_host_->contents_texture_manager()->
         UnlinkAndClearEvictedBackings();
@@ -674,8 +674,8 @@ void ThreadProxy::BeginFrame(
   layer_tree_host_->Layout();
 
   // Clear the commit flag after updating animations and layout here --- objects
-  // that only layout when painted will trigger another setNeedsCommit inside
-  // updateLayers.
+  // that only layout when painted will trigger another SetNeedsCommit inside
+  // UpdateLayers.
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
 
@@ -697,12 +697,12 @@ void ThreadProxy::BeginFrame(
 
   layer_tree_host_->WillCommit();
   // Before applying scrolls and calling animate, we set animate_requested_ to
-  // false. If it is true now, it means setNeedAnimate was called again, but
+  // false. If it is true now, it means SetNeedAnimate was called again, but
   // during a state when commit_request_sent_to_impl_thread_ = true. We need to
   // force that call to happen again now so that the commit request is sent to
   // the impl thread.
   if (animate_requested_) {
-    // Forces setNeedsAnimate to consider posting a commit task.
+    // Forces SetNeedsAnimate to consider posting a commit task.
     animate_requested_ = false;
     SetNeedsAnimate();
   }
@@ -716,7 +716,7 @@ void ThreadProxy::BeginFrame(
       created_offscreen_context_provider_ = true;
   }
 
-  // Notify the impl thread that the beginFrame has completed. This will
+  // Notify the impl thread that the BeginFrame has completed. This will
   // begin the commit process, which is blocking from the main thread's
   // point of view, but asynchronously performed on the impl thread,
   // coordinated by the Scheduler.
@@ -916,7 +916,7 @@ ThreadProxy::ScheduledActionDrawAndSwapInternal(bool forced_draw) {
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
-  // Check for a pending compositeAndReadback.
+  // Check for a pending CompositeAndReadback.
   if (readback_request_on_impl_thread_) {
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
@@ -1060,14 +1060,14 @@ void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion,
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
-  const base::TimeDelta displayRefreshInterval =
+  const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         60);
   scoped_ptr<FrameRateController> frame_rate_controller;
   if (render_vsync_enabled_) {
     frame_rate_controller.reset(
         new FrameRateController(DelayBasedTimeSource::Create(
-            displayRefreshInterval, Proxy::ImplThread())));
+            display_refresh_interval, Proxy::ImplThread())));
   } else {
     frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
   }
@@ -1108,14 +1108,14 @@ void ThreadProxy::InitializeRendererOnImplThread(
     scheduler_on_impl_thread_->SetSwapBuffersCompleteSupported(
         capabilities->using_swap_complete_callback);
 
-    int maxFramesPending = layer_tree_host_impl_->output_surface()->
+    int max_frames_pending = layer_tree_host_impl_->output_surface()->
         capabilities().max_frames_pending;
-    if (maxFramesPending <= 0)
-      maxFramesPending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
+    if (max_frames_pending <= 0)
+      max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
     if (layer_tree_host_impl_->output_surface()->capabilities().
             has_parent_compositor)
-      maxFramesPending = 1;
-    scheduler_on_impl_thread_->SetMaxFramesPending(maxFramesPending);
+      max_frames_pending = 1;
+    scheduler_on_impl_thread_->SetMaxFramesPending(max_frames_pending);
   }
 
   completion->Signal();
diff --git a/cc/trees/thread_proxy.h b/cc/trees/thread_proxy.h
index 5a235e3..67084a6 100644
--- a/cc/trees/thread_proxy.h
+++ b/cc/trees/thread_proxy.h
@@ -224,7 +224,7 @@ class ThreadProxy : public Proxy,
   scoped_ptr<OutputSurface>
       output_surface_before_initialization_on_impl_thread_;
 
-  // Set when the main thread is waiting on a scheduledActionBeginFrame to be
+  // Set when the main thread is waiting on a ScheduledActionBeginFrame to be
   // issued.
   CompletionEvent* begin_frame_completion_event_on_impl_thread_;
 
@@ -243,7 +243,7 @@ class ThreadProxy : public Proxy,
   scoped_ptr<ResourceUpdateController>
       current_resource_update_controller_on_impl_thread_;
 
-  // Set when the next draw should post didCommitAndDrawFrame to the main
+  // Set when the next draw should post DidCommitAndDrawFrame to the main
   // thread.
   bool next_frame_is_newly_committed_frame_on_impl_thread_;
 
diff --git a/cc/trees/tree_synchronizer.cc b/cc/trees/tree_synchronizer.cc
index 5bbfca6..130d404 100644
--- a/cc/trees/tree_synchronizer.cc
+++ b/cc/trees/tree_synchronizer.cc
@@ -148,7 +148,7 @@ void UpdateScrollbarLayerPointersRecursiveInternal(
   }
 
   ScrollbarLayerType* scrollbar_layer = layer->ToScrollbarLayer();
-  // Pinch-zoom scrollbars will have an invalid scrollLayerId, but they are
+  // Pinch-zoom scrollbars will have an invalid scroll_layer_id, but they are
   // managed by LayerTreeImpl and not LayerImpl, so should not be
   // processed here.
   if (!scrollbar_layer || (scrollbar_layer->scroll_layer_id() ==