cc: Remove opaque rect from cc::Picture.

cc/resources/picture.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/picture.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 104 matching lines @@
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
   // Read the picture. This creates an empty picture on failure.
   SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
   if (skpicture == NULL)
     return NULL;
 
   gfx::Rect layer_rect(skpicture->width(), skpicture->height());
-  gfx::Rect opaque_rect(skpicture->width(), skpicture->height());
-
-  return make_scoped_refptr(new Picture(skpicture, layer_rect, opaque_rect));
+  return make_scoped_refptr(new Picture(skpicture, layer_rect));
 }
 
 scoped_refptr<Picture> Picture::CreateFromValue(const base::Value* raw_value) {
   const base::DictionaryValue* value = NULL;
   if (!raw_value->GetAsDictionary(&value))
     return NULL;
 
   // Decode the picture from base64.
   std::string encoded;
   if (!value->GetString("skp64", &encoded))
     return NULL;
 
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
   const base::Value* layer_rect_value = NULL;
   if (!value->Get("params.layer_rect", &layer_rect_value))
     return NULL;
 
   gfx::Rect layer_rect;
   if (!MathUtil::FromValue(layer_rect_value, &layer_rect))
     return NULL;
 
-  const base::Value* opaque_rect_value = NULL;
-  if (!value->Get("params.opaque_rect", &opaque_rect_value))
-    return NULL;
-
-  gfx::Rect opaque_rect;
-  if (!MathUtil::FromValue(opaque_rect_value, &opaque_rect))
-    return NULL;
-
   // Read the picture. This creates an empty picture on failure.
   SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
   if (skpicture == NULL)
     return NULL;
 
-  return make_scoped_refptr(new Picture(skpicture, layer_rect, opaque_rect));
+  return make_scoped_refptr(new Picture(skpicture, layer_rect));
 }
 
-Picture::Picture(SkPicture* picture,
-                 const gfx::Rect& layer_rect,
-                 const gfx::Rect& opaque_rect) :
-    layer_rect_(layer_rect),
-    opaque_rect_(opaque_rect),
-    picture_(skia::AdoptRef(picture)),
-    cell_size_(layer_rect.size()) {
+Picture::Picture(SkPicture* picture, const gfx::Rect& layer_rect)
+    : layer_rect_(layer_rect),
+      picture_(skia::AdoptRef(picture)),
+      cell_size_(layer_rect.size()) {
 }
 
 Picture::Picture(const skia::RefPtr<SkPicture>& picture,
                  const gfx::Rect& layer_rect,
-                 const gfx::Rect& opaque_rect,
                  const PixelRefMap& pixel_refs) :
     layer_rect_(layer_rect),
-    opaque_rect_(opaque_rect),
     picture_(picture),
     pixel_refs_(pixel_refs),
     cell_size_(layer_rect.size()) {
 }
 
 Picture::~Picture() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
     TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::Picture", this);
 }
 
@@ skipping 87 matching lines @@
   picture_ = skia::AdoptRef(recorder.endRecording());
   DCHECK(picture_);
 
   if (recording) {
     // SkRecording requires it's the only one holding onto canvas before we
     // may call releasePlayback().  (This helps enforce thread-safety.)
     canvas.clear();
     playback_.reset(recording->releasePlayback());
   }
 
-  opaque_rect_ = gfx::ToEnclosedRect(opaque_layer_rect);
-
   EmitTraceSnapshot();
 }
 
 void Picture::GatherPixelRefs(
     const SkTileGridFactory::TileGridInfo& tile_grid_info) {
   TRACE_EVENT2("cc", "Picture::GatherPixelRefs",
                "width", layer_rect_.width(),
                "height", layer_rect_.height());
 
   DCHECK(picture_);
@@ skipping 108 matching lines @@
     skia::RefPtr<SkPicture> picture(skia::AdoptRef(recorder.endRecording()));
     picture->serialize(&stream, &EncodeBitmap);
   } else {
     // Serialize the picture.
     picture_->serialize(&stream, &EncodeBitmap);
   }
 
   // Encode the picture as base64.
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
   res->Set("params.layer_rect", MathUtil::AsValue(layer_rect_).release());
-  res->Set("params.opaque_rect", MathUtil::AsValue(opaque_rect_).release());
 
   size_t serialized_size = stream.bytesWritten();
   scoped_ptr<char[]> serialized_picture(new char[serialized_size]);
   stream.copyTo(serialized_picture.get());
   std::string b64_picture;
   base::Base64Encode(std::string(serialized_picture.get(), serialized_size),
                      &b64_picture);
   res->SetString("skp64", b64_picture);
   return res.PassAs<base::Value>();
 }
@@ skipping 130 matching lines @@
   scoped_refptr<base::debug::TracedValue> record_data =
       new base::debug::TracedValue();
   TracedValue::SetIDRef(this, record_data.get(), "picture_id");
   record_data->BeginArray("layer_rect");
   MathUtil::AddToTracedValue(layer_rect_, record_data.get());
   record_data->EndArray();
   return record_data;
 }
 
 }  // namespace cc