Record SkPicture with correct LCD text setting.

cc/resources/picture_unittest.cc

 // Copyright 2013 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/resources/picture.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/test/fake_content_layer_client.h"
@@ skipping 39 matching lines @@
 
   // Single full-size rect picture.
   content_layer_client.add_draw_rect(layer_rect, red_paint);
 
   for (size_t i = 0; i < arraysize(kRecordingModes); ++i) {
     scoped_refptr<Picture> one_rect_picture =
         Picture::Create(layer_rect,
                         &content_layer_client,
                         tile_grid_info,
                         false,
+                        false,
                         0,
                         kRecordingModes[i]);
     scoped_ptr<base::Value> serialized_one_rect(one_rect_picture->AsValue());
 
     // Reconstruct the picture.
     scoped_refptr<Picture> one_rect_picture_check =
         Picture::CreateFromValue(serialized_one_rect.get());
     EXPECT_TRUE(!!one_rect_picture_check.get());
 
     // Check for equivalence.
@@ skipping 12 matching lines @@
 
   // Two rect picture.
   content_layer_client.add_draw_rect(gfx::Rect(25, 25, 50, 50), green_paint);
 
   for (size_t i = 0; i < arraysize(kRecordingModes); ++i) {
     scoped_refptr<Picture> two_rect_picture =
         Picture::Create(layer_rect,
                         &content_layer_client,
                         tile_grid_info,
                         false,
+                        false,
                         0,
                         Picture::RECORD_NORMALLY);
 
     scoped_ptr<base::Value> serialized_two_rect(two_rect_picture->AsValue());
 
     // Reconstruct the picture.
     scoped_refptr<Picture> two_rect_picture_check =
         Picture::CreateFromValue(serialized_two_rect.get());
     EXPECT_TRUE(!!two_rect_picture_check.get());
 
@@ skipping 43 matching lines @@
             discardable_bitmap[y][x],
             gfx::Point(x * 512 + 6, y * 512 + 6), paint);
       }
     }
   }
 
   scoped_refptr<Picture> picture = Picture::Create(layer_rect,
                                                    &content_layer_client,
                                                    tile_grid_info,
                                                    true,
+                                                   false,
                                                    0,
                                                    Picture::RECORD_NORMALLY);
 
   // Default iterator does not have any pixel refs
   {
     Picture::PixelRefIterator iterator;
     EXPECT_FALSE(iterator);
   }
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
@@ skipping 81 matching lines @@
             discardable_bitmap[y][x],
             gfx::Point(1024 + x * 512 + 6, y * 512 + 6), paint);
       }
     }
   }
 
   scoped_refptr<Picture> picture = Picture::Create(layer_rect,
                                                    &content_layer_client,
                                                    tile_grid_info,
                                                    true,
+                                                   false,
                                                    0,
                                                    Picture::RECORD_NORMALLY);
 
   // Default iterator does not have any pixel refs
   {
     Picture::PixelRefIterator iterator;
     EXPECT_FALSE(iterator);
   }
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
@@ skipping 104 matching lines @@
             discardable_bitmap[y][x],
             gfx::Point(x * 512 + 6, y * 512 + 6), paint);
       }
     }
   }
 
   scoped_refptr<Picture> picture = Picture::Create(layer_rect,
                                                    &content_layer_client,
                                                    tile_grid_info,
                                                    true,
+                                                   false,
                                                    0,
                                                    Picture::RECORD_NORMALLY);
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       Picture::PixelRefIterator iterator(
           gfx::Rect(x * 512, y * 512 + 256, 1, 1), picture.get());
       if ((x + y) & 1) {
         EXPECT_TRUE(iterator) << x << " " << y;
         EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef());
@@ skipping 30 matching lines @@
       Picture::CreateFromSkpValue(tmp.get());
   EXPECT_TRUE(!invalid_picture.get());
 
   // Single full-size rect picture.
   content_layer_client.add_draw_rect(layer_rect, red_paint);
   scoped_refptr<Picture> one_rect_picture =
       Picture::Create(layer_rect,
                       &content_layer_client,
                       tile_grid_info,
                       false,
+                      false,
                       0,
                       Picture::RECORD_NORMALLY);
   scoped_ptr<base::Value> serialized_one_rect(
       one_rect_picture->AsValue());
 
   const base::DictionaryValue* value = NULL;
   EXPECT_TRUE(serialized_one_rect->GetAsDictionary(&value));
 
   // Decode the picture from base64.
   const base::Value* skp_value;
@@ skipping 20 matching lines @@
   tile_grid_info.fMargin.setEmpty();
   tile_grid_info.fOffset.setZero();
 
   FakeContentLayerClient content_layer_client;
   EXPECT_EQ(NULL, content_layer_client.last_canvas());
 
   scoped_refptr<Picture> picture = Picture::Create(layer_rect,
                                                    &content_layer_client,
                                                    tile_grid_info,
                                                    false,
+                                                   false,
                                                    0,
                                                    Picture::RECORD_NORMALLY);
   EXPECT_TRUE(content_layer_client.last_canvas() != NULL);
   EXPECT_EQ(ContentLayerClient::GRAPHICS_CONTEXT_ENABLED,
             content_layer_client.last_context_status());
   EXPECT_TRUE(picture);
 
   picture = Picture::Create(layer_rect,
                             &content_layer_client,
                             tile_grid_info,
                             false,
+                            false,
                             0,
                             Picture::RECORD_WITH_SK_NULL_CANVAS);
   EXPECT_TRUE(content_layer_client.last_canvas() != NULL);
   EXPECT_EQ(ContentLayerClient::GRAPHICS_CONTEXT_ENABLED,
             content_layer_client.last_context_status());
   EXPECT_TRUE(picture);
 
   picture = Picture::Create(layer_rect,
                             &content_layer_client,
                             tile_grid_info,
                             false,
+                            false,
                             0,
                             Picture::RECORD_WITH_PAINTING_DISABLED);
   EXPECT_TRUE(content_layer_client.last_canvas() != NULL);
   EXPECT_EQ(ContentLayerClient::GRAPHICS_CONTEXT_DISABLED,
             content_layer_client.last_context_status());
   EXPECT_TRUE(picture);
 
   picture = Picture::Create(layer_rect,
                             &content_layer_client,
                             tile_grid_info,
                             false,
+                            false,
                             0,
                             Picture::RECORD_WITH_SKRECORD);
   EXPECT_TRUE(content_layer_client.last_canvas() != NULL);
   EXPECT_TRUE(picture);
 
   EXPECT_EQ(4, Picture::RECORDING_MODE_COUNT);
 }
 
 }  // namespace
 }  // namespace cc