diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 0ffd466..bb6312a 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -778,6 +778,7 @@
     "paint/discardable_image_map_unittest.cc",
     "paint/display_item_list_unittest.cc",
     "paint/paint_op_buffer_unittest.cc",
+    "paint/solid_color_analyzer_unittest.cc",
     "quads/draw_polygon_unittest.cc",
     "quads/draw_quad_unittest.cc",
     "quads/nine_patch_generator_unittest.cc",
diff --git a/cc/benchmarks/rasterize_and_record_benchmark_impl.cc b/cc/benchmarks/rasterize_and_record_benchmark_impl.cc
index 203f770..3052425 100644
--- a/cc/benchmarks/rasterize_and_record_benchmark_impl.cc
+++ b/cc/benchmarks/rasterize_and_record_benchmark_impl.cc
@@ -45,8 +45,10 @@
                    base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                    kTimeCheckInterval);
     SkColor color = SK_ColorTRANSPARENT;
-    *is_solid_color = raster_source->PerformSolidColorAnalysis(
-        content_rect, contents_scale, &color);
+    gfx::Rect layer_rect =
+        gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
+    *is_solid_color =
+        raster_source->PerformSolidColorAnalysis(layer_rect, &color);
 
     do {
       SkBitmap bitmap;
diff --git a/cc/layers/recording_source.cc b/cc/layers/recording_source.cc
index e48e0ce..06defb1 100644
--- a/cc/layers/recording_source.cc
+++ b/cc/layers/recording_source.cc
@@ -12,6 +12,7 @@
 #include "cc/base/region.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/paint/display_item_list.h"
+#include "cc/paint/solid_color_analyzer.h"
 #include "cc/raster/raster_source.h"
 #include "skia/ext/analysis_canvas.h"
 
@@ -142,15 +143,14 @@
   is_solid_color_ = false;
   solid_color_ = SK_ColorTRANSPARENT;
 
+  // TODO(vmpstr): We can probably remove this check.
   if (!display_list_->ShouldBeAnalyzedForSolidColor())
     return;
 
   TRACE_EVENT1("cc", "RecordingSource::DetermineIfSolidColor", "opcount",
                display_list_->op_count());
-  gfx::Size layer_size = GetSize();
-  skia::AnalysisCanvas canvas(layer_size.width(), layer_size.height());
-  display_list_->Raster(&canvas);
-  is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
+  is_solid_color_ =
+      display_list_->GetColorIfSolidInRect(gfx::Rect(GetSize()), &solid_color_);
 }
 
 }  // namespace cc
diff --git a/cc/paint/BUILD.gn b/cc/paint/BUILD.gn
index baa9458a..57de616 100644
--- a/cc/paint/BUILD.gn
+++ b/cc/paint/BUILD.gn
@@ -35,6 +35,8 @@
     "record_paint_canvas.h",
     "skia_paint_canvas.cc",
     "skia_paint_canvas.h",
+    "solid_color_analyzer.cc",
+    "solid_color_analyzer.h",
   ]
 
   defines = [ "CC_PAINT_IMPLEMENTATION=1" ]
diff --git a/cc/paint/display_item_list.cc b/cc/paint/display_item_list.cc
index a79d886c..8945e5a 100644
--- a/cc/paint/display_item_list.cc
+++ b/cc/paint/display_item_list.cc
@@ -15,6 +15,7 @@
 #include "cc/base/render_surface_filters.h"
 #include "cc/debug/picture_debug_util.h"
 #include "cc/paint/discardable_image_store.h"
+#include "cc/paint/solid_color_analyzer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/geometry/rect.h"
@@ -200,4 +201,23 @@
   return record;
 }
 
+bool DisplayItemList::GetColorIfSolidInRect(const gfx::Rect& rect,
+                                            SkColor* color) {
+  std::vector<size_t>* indices_to_use = nullptr;
+  std::vector<size_t> indices;
+  if (!rect.Contains(rtree_.GetBounds())) {
+    indices = rtree_.Search(rect);
+    indices_to_use = &indices;
+  }
+
+  base::Optional<SkColor> solid_color =
+      SolidColorAnalyzer::DetermineIfSolidColor(&paint_op_buffer_, rect,
+                                                indices_to_use);
+  if (solid_color) {
+    *color = *solid_color;
+    return true;
+  }
+  return false;
+}
+
 }  // namespace cc
diff --git a/cc/paint/display_item_list.h b/cc/paint/display_item_list.h
index fe3bdc7..e419e04 100644
--- a/cc/paint/display_item_list.h
+++ b/cc/paint/display_item_list.h
@@ -138,6 +138,8 @@
   // an empty state.
   sk_sp<PaintRecord> ReleaseAsRecord();
 
+  bool GetColorIfSolidInRect(const gfx::Rect& rect, SkColor* color);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(DisplayItemListTest, AsValueWithNoOps);
   FRIEND_TEST_ALL_PREFIXES(DisplayItemListTest, AsValueWithOps);
diff --git a/cc/paint/paint_flags.h b/cc/paint/paint_flags.h
index 07e579a..6954892d 100644
--- a/cc/paint/paint_flags.h
+++ b/cc/paint/paint_flags.h
@@ -27,6 +27,7 @@
     kStroke_Style = SkPaint::kStroke_Style,
     kStrokeAndFill_Style = SkPaint::kStrokeAndFill_Style,
   };
+  ALWAYS_INLINE bool nothingToDraw() const { return paint_.nothingToDraw(); }
   ALWAYS_INLINE Style getStyle() const {
     return static_cast<Style>(paint_.getStyle());
   }
diff --git a/cc/paint/solid_color_analyzer.cc b/cc/paint/solid_color_analyzer.cc
new file mode 100644
index 0000000..9aac466a
--- /dev/null
+++ b/cc/paint/solid_color_analyzer.cc
@@ -0,0 +1,255 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/paint/solid_color_analyzer.h"
+
+#include "base/trace_event/trace_event.h"
+#include "cc/paint/paint_op_buffer.h"
+#include "third_party/skia/include/utils/SkNoDrawCanvas.h"
+
+namespace cc {
+namespace {
+const int kMaxOpsToAnalyze = 1;
+
+bool ActsLikeClear(SkBlendMode mode, unsigned src_alpha) {
+  switch (mode) {
+    case SkBlendMode::kClear:
+      return true;
+    case SkBlendMode::kSrc:
+    case SkBlendMode::kSrcIn:
+    case SkBlendMode::kDstIn:
+    case SkBlendMode::kSrcOut:
+    case SkBlendMode::kDstATop:
+      return src_alpha == 0;
+    case SkBlendMode::kDstOut:
+      return src_alpha == 0xFF;
+    default:
+      return false;
+  }
+}
+
+bool IsSolidColor(SkColor color, SkBlendMode blendmode) {
+  return SkColorGetA(color) == 255 &&
+         (blendmode == SkBlendMode::kSrc || blendmode == SkBlendMode::kSrcOver);
+}
+
+bool IsSolidColorPaint(const PaintFlags& flags) {
+  SkBlendMode blendmode = flags.getBlendMode();
+
+  // Paint is solid color if the following holds:
+  // - Alpha is 1.0, style is fill, and there are no special effects
+  // - Xfer mode is either kSrc or kSrcOver (kSrcOver is equivalent
+  //   to kSrc if source alpha is 1.0, which is already checked).
+  return IsSolidColor(flags.getColor(), blendmode) && !flags.HasShader() &&
+         !flags.getLooper() && !flags.getMaskFilter() &&
+         !flags.getColorFilter() && !flags.getImageFilter() &&
+         flags.getStyle() == PaintFlags::kFill_Style;
+}
+
+// Returns true if the specified drawn_rect will cover the entire canvas, and
+// that the canvas is not clipped (i.e. it covers ALL of the canvas).
+bool IsFullQuad(const SkCanvas& canvas, const SkRect& drawn_rect) {
+  if (!canvas.isClipRect())
+    return false;
+
+  SkIRect clip_irect;
+  if (!canvas.getDeviceClipBounds(&clip_irect))
+    return false;
+
+  // if the clip is smaller than the canvas, we're partly clipped, so abort.
+  if (!clip_irect.contains(SkIRect::MakeSize(canvas.getBaseLayerSize())))
+    return false;
+
+  const SkMatrix& matrix = canvas.getTotalMatrix();
+  // If the transform results in a non-axis aligned
+  // rect, then be conservative and return false.
+  if (!matrix.rectStaysRect())
+    return false;
+
+  SkRect device_rect;
+  matrix.mapRect(&device_rect, drawn_rect);
+  SkRect clip_rect;
+  clip_rect.set(clip_irect);
+  return device_rect.contains(clip_rect);
+}
+
+void CheckIfSolidColor(const SkCanvas& canvas,
+                       SkColor color,
+                       SkBlendMode blendmode,
+                       bool* is_solid_color,
+                       bool* is_transparent,
+                       SkColor* out_color) {
+  SkRect rect;
+  if (!canvas.getLocalClipBounds(&rect)) {
+    *is_transparent = false;
+    *is_solid_color = false;
+    return;
+  }
+
+  bool does_cover_canvas = IsFullQuad(canvas, rect);
+  uint8_t alpha = SkColorGetA(color);
+  if (does_cover_canvas && ActsLikeClear(blendmode, alpha))
+    *is_transparent = true;
+  else if (alpha != 0 || blendmode != SkBlendMode::kSrc)
+    *is_transparent = false;
+
+  if (does_cover_canvas && IsSolidColor(color, blendmode)) {
+    *is_solid_color = true;
+    *out_color = color;
+  } else {
+    *is_solid_color = false;
+  }
+}
+
+void CheckIfSolidRect(const SkCanvas& canvas,
+                      const SkRect& rect,
+                      const PaintFlags& flags,
+                      bool* is_solid_color,
+                      bool* is_transparent,
+                      SkColor* color) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "SolidColorAnalyzer::HandleDrawRect");
+  if (flags.nothingToDraw())
+    return;
+
+  bool does_cover_canvas = IsFullQuad(canvas, rect);
+  SkBlendMode blendmode = flags.getBlendMode();
+  if (does_cover_canvas && ActsLikeClear(blendmode, flags.getAlpha()))
+    *is_transparent = true;
+  else if (flags.getAlpha() != 0 || blendmode != SkBlendMode::kSrc)
+    *is_transparent = false;
+
+  if (does_cover_canvas && IsSolidColorPaint(flags)) {
+    *is_solid_color = true;
+    *color = flags.getColor();
+  } else {
+    *is_solid_color = false;
+  }
+}
+
+}  // namespace
+
+base::Optional<SkColor> SolidColorAnalyzer::DetermineIfSolidColor(
+    const PaintOpBuffer* buffer,
+    const gfx::Rect& rect,
+    const std::vector<size_t>* indices) {
+  if (buffer->size() == 0 || (indices && indices->empty()))
+    return SK_ColorTRANSPARENT;
+
+  bool is_solid = false;
+  bool is_transparent = true;
+  SkColor color = SK_ColorTRANSPARENT;
+
+  struct Frame {
+    Frame() = default;
+    Frame(PaintOpBuffer::Iterator iter,
+          const SkMatrix& original_ctm,
+          int save_count)
+        : iter(iter), original_ctm(original_ctm), save_count(save_count) {}
+
+    PaintOpBuffer::Iterator iter;
+    const SkMatrix original_ctm;
+    int save_count = 0;
+  };
+
+  SkNoDrawCanvas canvas(rect.width(), rect.height());
+  canvas.translate(-rect.x(), -rect.y());
+  canvas.clipRect(gfx::RectToSkRect(rect), SkClipOp::kIntersect, false);
+
+  std::vector<Frame> stack;
+  // We expect to see at least one DrawRecordOp because of the way items are
+  // constructed. Reserve this to 2, and go from there.
+  stack.reserve(2);
+  stack.emplace_back(PaintOpBuffer::Iterator(buffer, indices),
+                     canvas.getTotalMatrix(), canvas.getSaveCount());
+
+  int num_ops = 0;
+  while (!stack.empty()) {
+    auto& frame = stack.back();
+    if (!frame.iter) {
+      canvas.restoreToCount(frame.save_count);
+      stack.pop_back();
+      if (!stack.empty())
+        ++stack.back().iter;
+      continue;
+    }
+
+    const PaintOp* op = *frame.iter;
+    const SkMatrix& original_ctm = frame.original_ctm;
+    switch (op->GetType()) {
+      case PaintOpType::DrawRecord: {
+        const DrawRecordOp* record_op = static_cast<const DrawRecordOp*>(op);
+        stack.emplace_back(PaintOpBuffer::Iterator(record_op->record.get()),
+                           canvas.getTotalMatrix(), canvas.getSaveCount());
+        continue;
+      }
+
+      // Any of the following ops result in non solid content.
+      case PaintOpType::DrawArc:
+      case PaintOpType::DrawCircle:
+      case PaintOpType::DrawDRRect:
+      case PaintOpType::DrawImage:
+      case PaintOpType::DrawImageRect:
+      case PaintOpType::DrawIRect:
+      case PaintOpType::DrawLine:
+      case PaintOpType::DrawOval:
+      case PaintOpType::DrawPath:
+      case PaintOpType::DrawPosText:
+      case PaintOpType::DrawRRect:
+      case PaintOpType::DrawText:
+      case PaintOpType::DrawTextBlob:
+      // Anything that has to do a save layer is probably not solid. As it will
+      // likely need more than one draw op.
+      // TODO(vmpstr): We could investigate handling these.
+      case PaintOpType::SaveLayer:
+      case PaintOpType::SaveLayerAlpha:
+      // Complex clips will probably result in non solid color as it might not
+      // cover the canvas.
+      // TODO(vmpstr): We could investigate handling these.
+      case PaintOpType::ClipPath:
+      case PaintOpType::ClipRRect:
+        return base::nullopt;
+
+      case PaintOpType::DrawRect: {
+        if (++num_ops > kMaxOpsToAnalyze)
+          return base::nullopt;
+        const DrawRectOp* rect_op = static_cast<const DrawRectOp*>(op);
+        CheckIfSolidRect(canvas, rect_op->rect, rect_op->flags, &is_solid,
+                         &is_transparent, &color);
+        break;
+      }
+      case PaintOpType::DrawColor: {
+        if (++num_ops > kMaxOpsToAnalyze)
+          return base::nullopt;
+        const DrawColorOp* color_op = static_cast<const DrawColorOp*>(op);
+        CheckIfSolidColor(canvas, color_op->color, color_op->mode, &is_solid,
+                          &is_transparent, &color);
+        break;
+      }
+
+      // The rest of the ops should only affect our state canvas.
+      case PaintOpType::Annotate:
+      case PaintOpType::ClipRect:
+      case PaintOpType::Concat:
+      case PaintOpType::Scale:
+      case PaintOpType::SetMatrix:
+      case PaintOpType::Restore:
+      case PaintOpType::Rotate:
+      case PaintOpType::Save:
+      case PaintOpType::Translate:
+      case PaintOpType::Noop:
+        op->Raster(&canvas, original_ctm);
+        break;
+    }
+    ++frame.iter;
+  }
+
+  if (is_transparent)
+    return SK_ColorTRANSPARENT;
+  if (is_solid)
+    return color;
+  return base::nullopt;
+}
+
+}  // namespace cc
diff --git a/cc/paint/solid_color_analyzer.h b/cc/paint/solid_color_analyzer.h
new file mode 100644
index 0000000..f0d9f26
--- /dev/null
+++ b/cc/paint/solid_color_analyzer.h
@@ -0,0 +1,30 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_PAINT_SOLID_COLOR_ANALYZER_H_
+#define CC_PAINT_SOLID_COLOR_ANALYZER_H_
+
+#include <vector>
+
+#include "base/optional.h"
+#include "cc/paint/paint_export.h"
+#include "cc/paint/paint_flags.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+
+class CC_PAINT_EXPORT SolidColorAnalyzer {
+ public:
+  SolidColorAnalyzer() = delete;
+
+  static base::Optional<SkColor> DetermineIfSolidColor(
+      const PaintOpBuffer* buffer,
+      const gfx::Rect& rect,
+      const std::vector<size_t>* indices = nullptr);
+};
+
+}  // namespace cc
+
+#endif  // CC_PAINT_SOLID_COLOR_ANALYZER_H_
diff --git a/cc/paint/solid_color_analyzer_unittest.cc b/cc/paint/solid_color_analyzer_unittest.cc
new file mode 100644
index 0000000..a56d107
--- /dev/null
+++ b/cc/paint/solid_color_analyzer_unittest.cc
@@ -0,0 +1,250 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/paint/solid_color_analyzer.h"
+#include "base/optional.h"
+#include "cc/paint/record_paint_canvas.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/effects/SkOffsetImageFilter.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+namespace {
+
+class SolidColorAnalyzerTest : public testing::Test {
+ public:
+  void SetUp() override {}
+
+  void TearDown() override {
+    canvas_.reset();
+    buffer_.Reset();
+  }
+
+  void Initialize(const gfx::Rect& rect = gfx::Rect(0, 0, 100, 100)) {
+    canvas_.emplace(&buffer_, gfx::RectToSkRect(rect));
+    rect_ = rect;
+  }
+  RecordPaintCanvas* canvas() { return &*canvas_; }
+  PaintOpBuffer* paint_op_buffer() { return &buffer_; }
+
+  bool IsSolidColor() {
+    auto color =
+        SolidColorAnalyzer::DetermineIfSolidColor(&buffer_, rect_, nullptr);
+    return !!color;
+  }
+
+  SkColor GetColor() const {
+    auto color =
+        SolidColorAnalyzer::DetermineIfSolidColor(&buffer_, rect_, nullptr);
+    EXPECT_TRUE(color);
+    return color ? *color : SK_ColorTRANSPARENT;
+  }
+
+ private:
+  gfx::Rect rect_;
+  PaintOpBuffer buffer_;
+  base::Optional<RecordPaintCanvas> canvas_;
+  base::Optional<SolidColorAnalyzer> analyzer_;
+};
+
+TEST_F(SolidColorAnalyzerTest, Empty) {
+  Initialize();
+  EXPECT_EQ(SK_ColorTRANSPARENT, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, ClearTransparent) {
+  Initialize();
+  SkColor color = SkColorSetARGB(0, 12, 34, 56);
+  canvas()->clear(color);
+  EXPECT_EQ(SK_ColorTRANSPARENT, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, ClearSolid) {
+  Initialize();
+  SkColor color = SkColorSetARGB(255, 65, 43, 21);
+  canvas()->clear(color);
+  EXPECT_EQ(color, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, ClearTranslucent) {
+  Initialize();
+  SkColor color = SkColorSetARGB(128, 11, 22, 33);
+  canvas()->clear(color);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawColor) {
+  Initialize();
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  canvas()->drawColor(color);
+  EXPECT_EQ(color, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawOval) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  canvas()->drawOval(SkRect::MakeWH(100, 100), flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawBitmap) {
+  Initialize();
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(16, 16);
+  canvas()->drawBitmap(bitmap, 0, 0, nullptr);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRect) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->clipRect(rect, SkClipOp::kIntersect, false);
+  canvas()->drawRect(rect, flags);
+  EXPECT_EQ(color, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectClipped) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->clipRect(SkRect::MakeWH(50, 50), SkClipOp::kIntersect, false);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectWithTranslateNotSolid) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(100, 100);
+  canvas()->translate(1, 1);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectWithTranslateSolid) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(101, 101);
+  canvas()->translate(1, 1);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, TwoOpsNotSolid) {
+  Initialize();
+  SkColor color = SkColorSetARGB(255, 65, 43, 21);
+  canvas()->clear(color);
+  canvas()->clear(color);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectBlendModeClear) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  flags.setBlendMode(SkBlendMode::kClear);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->drawRect(rect, flags);
+  EXPECT_EQ(SK_ColorTRANSPARENT, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectBlendModeSrcOver) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  flags.setBlendMode(SkBlendMode::kSrcOver);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->drawRect(rect, flags);
+  EXPECT_EQ(color, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectRotated) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->rotate(50);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectScaledNotSolid) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->scale(0.1f, 0.1f);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectScaledSolid) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  SkRect rect = SkRect::MakeWH(10, 10);
+  canvas()->scale(10, 10);
+  canvas()->drawRect(rect, flags);
+  EXPECT_EQ(color, GetColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectFilterPaint) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+  flags.setImageFilter(SkOffsetImageFilter::Make(10, 10, nullptr));
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, DrawRectClipPath) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+
+  SkPath path;
+  path.moveTo(0, 0);
+  path.lineTo(128, 50);
+  path.lineTo(255, 0);
+  path.lineTo(255, 255);
+  path.lineTo(0, 255);
+
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->clipPath(path, SkClipOp::kIntersect);
+  canvas()->drawRect(rect, flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+TEST_F(SolidColorAnalyzerTest, SaveLayer) {
+  Initialize();
+  PaintFlags flags;
+  SkColor color = SkColorSetARGB(255, 11, 22, 33);
+  flags.setColor(color);
+
+  SkRect rect = SkRect::MakeWH(200, 200);
+  canvas()->saveLayer(&rect, &flags);
+  EXPECT_FALSE(IsSolidColor());
+}
+
+}  // namespace
+}  // namespace cc
diff --git a/cc/raster/raster_source.cc b/cc/raster/raster_source.cc
index 9294cd6..124d5c5 100644
--- a/cc/raster/raster_source.cc
+++ b/cc/raster/raster_source.cc
@@ -237,21 +237,12 @@
   return display_list_->BytesUsed() + painter_reported_memory_usage_;
 }
 
-bool RasterSource::PerformSolidColorAnalysis(const gfx::Rect& content_rect,
-                                             float contents_scale,
+bool RasterSource::PerformSolidColorAnalysis(gfx::Rect layer_rect,
                                              SkColor* color) const {
   TRACE_EVENT0("cc", "RasterSource::PerformSolidColorAnalysis");
 
-  gfx::Rect layer_rect =
-      gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
-
   layer_rect.Intersect(gfx::Rect(size_));
-  skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
-  canvas.translate(-layer_rect.x(), -layer_rect.y());
-  // Note that because no color conversion is applied to solid color analysis,
-  // the resulting solid color will be known to be sRGB.
-  RasterCommon(&canvas, &canvas);
-  return canvas.GetColorIfSolid(color);
+  return display_list_->GetColorIfSolidInRect(layer_rect, color);
 }
 
 void RasterSource::GetDiscardableImagesInRect(
diff --git a/cc/raster/raster_source.h b/cc/raster/raster_source.h
index 92e429b..8479de1a 100644
--- a/cc/raster/raster_source.h
+++ b/cc/raster/raster_source.h
@@ -89,9 +89,7 @@
 
   // Returns whether the given rect at given scale is of solid color in
   // this raster source, as well as the solid color value.
-  bool PerformSolidColorAnalysis(const gfx::Rect& content_rect,
-                                 float contents_scale,
-                                 SkColor* color) const;
+  bool PerformSolidColorAnalysis(gfx::Rect content_rect, SkColor* color) const;
 
   // Returns true iff the whole raster source is of solid color.
   bool IsSolidColor() const;
diff --git a/cc/raster/raster_source_unittest.cc b/cc/raster/raster_source_unittest.cc
index 5cb06aaf..c75fcb8 100644
--- a/cc/raster/raster_source_unittest.cc
+++ b/cc/raster/raster_source_unittest.cc
@@ -53,7 +53,7 @@
   for (int y = 0; y <= 300; y += 100) {
     for (int x = 0; x <= 300; x += 100) {
       gfx::Rect rect(x, y, 100, 100);
-      is_solid_color = raster->PerformSolidColorAnalysis(rect, 1.f, &color);
+      is_solid_color = raster->PerformSolidColorAnalysis(rect, &color);
       EXPECT_TRUE(is_solid_color) << rect.ToString();
       EXPECT_EQ(solid_color, color) << rect.ToString();
     }
@@ -68,124 +68,35 @@
 
   color = SK_ColorTRANSPARENT;
   is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), 1.f, &color);
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), &color);
   EXPECT_FALSE(is_solid_color);
 
   color = SK_ColorTRANSPARENT;
-  is_solid_color = raster->PerformSolidColorAnalysis(
-      gfx::Rect(100, 0, 100, 100), 1.f, &color);
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(100, 0, 100, 100), &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(solid_color, color);
 
   // Boundaries should be clipped.
   color = SK_ColorTRANSPARENT;
-  is_solid_color = raster->PerformSolidColorAnalysis(
-      gfx::Rect(350, 0, 100, 100), 1.f, &color);
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(350, 0, 100, 100), &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(solid_color, color);
 
   color = SK_ColorTRANSPARENT;
-  is_solid_color = raster->PerformSolidColorAnalysis(
-      gfx::Rect(0, 350, 100, 100), 1.f, &color);
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 350, 100, 100), &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(solid_color, color);
 
   color = SK_ColorTRANSPARENT;
-  is_solid_color = raster->PerformSolidColorAnalysis(
-      gfx::Rect(350, 350, 100, 100), 1.f, &color);
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(350, 350, 100, 100), &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(solid_color, color);
 }
 
-TEST(RasterSourceTest, AnalyzeIsSolidScaled) {
-  gfx::Size layer_bounds(400, 400);
-
-  std::unique_ptr<FakeRecordingSource> recording_source =
-      FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
-
-  SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
-  SkColor color = SK_ColorTRANSPARENT;
-  PaintFlags solid_flags;
-  bool is_solid_color = false;
-  solid_flags.setColor(solid_color);
-
-  SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
-  PaintFlags non_solid_flags;
-  non_solid_flags.setColor(non_solid_color);
-
-  recording_source->add_draw_rect_with_flags(gfx::Rect(0, 0, 400, 400),
-                                             solid_flags);
-  recording_source->Rerecord();
-
-  scoped_refptr<RasterSource> raster =
-      RasterSource::CreateFromRecordingSource(recording_source.get(), false);
-
-  // Ensure everything is solid.
-  for (int y = 0; y <= 30; y += 10) {
-    for (int x = 0; x <= 30; x += 10) {
-      gfx::Rect rect(x, y, 10, 10);
-      is_solid_color = raster->PerformSolidColorAnalysis(rect, 0.1f, &color);
-      EXPECT_TRUE(is_solid_color) << rect.ToString();
-      EXPECT_EQ(color, solid_color) << rect.ToString();
-    }
-  }
-
-  // Add one non-solid pixel and recreate the raster source.
-  recording_source->add_draw_rect_with_flags(gfx::Rect(50, 50, 1, 1),
-                                             non_solid_flags);
-  recording_source->Rerecord();
-  raster =
-      RasterSource::CreateFromRecordingSource(recording_source.get(), false);
-
-  color = SK_ColorTRANSPARENT;
-  is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 10, 10), 0.1f, &color);
-  EXPECT_FALSE(is_solid_color);
-
-  color = SK_ColorTRANSPARENT;
-  is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(10, 0, 10, 10), 0.1f, &color);
-  EXPECT_TRUE(is_solid_color);
-  EXPECT_EQ(color, solid_color);
-
-  // Boundaries should be clipped.
-  color = SK_ColorTRANSPARENT;
-  is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(35, 0, 10, 10), 0.1f, &color);
-  EXPECT_TRUE(is_solid_color);
-  EXPECT_EQ(color, solid_color);
-
-  color = SK_ColorTRANSPARENT;
-  is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(0, 35, 10, 10), 0.1f, &color);
-  EXPECT_TRUE(is_solid_color);
-  EXPECT_EQ(color, solid_color);
-
-  color = SK_ColorTRANSPARENT;
-  is_solid_color = raster->PerformSolidColorAnalysis(gfx::Rect(35, 35, 10, 10),
-                                                     0.1f, &color);
-  EXPECT_TRUE(is_solid_color);
-  EXPECT_EQ(color, solid_color);
-}
-
-TEST(RasterSourceTest, AnalyzeIsSolidEmpty) {
-  gfx::Size layer_bounds(400, 400);
-
-  std::unique_ptr<FakeRecordingSource> recording_source =
-      FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
-  recording_source->Rerecord();
-
-  scoped_refptr<RasterSource> raster =
-      RasterSource::CreateFromRecordingSource(recording_source.get(), false);
-
-  SkColor color = SK_ColorTRANSPARENT;
-  bool is_solid_color =
-      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 400, 400), 1.f, &color);
-
-  EXPECT_TRUE(is_solid_color);
-  EXPECT_EQ(color, SkColorSetARGB(0, 0, 0, 0));
-}
-
 TEST(RasterSourceTest, PixelRefIteratorDiscardableRefsOneTile) {
   gfx::Size layer_bounds(512, 512);
 
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 2e78129..d9a680d6 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -685,11 +685,9 @@
       // canvas which is reset between tiles.
       tile->set_solid_color_analysis_performed(true);
       SkColor color = SK_ColorTRANSPARENT;
-      gfx::RectF layer_rect = tile->raster_transform().InverseMapRect(
-          gfx::RectF(tile->content_rect()));
       bool is_solid_color =
           prioritized_tile.raster_source()->PerformSolidColorAnalysis(
-              gfx::ToEnclosingRect(layer_rect), 1.f, &color);
+              tile->enclosing_layer_rect(), &color);
       if (is_solid_color) {
         tile->draw_info().set_solid_color(color);
         client_->NotifyTileStateChanged(tile);