Rename WebKit namespace to blink (part 3)

content/test/image_decoder_test.cc

 // Copyright (c) 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 "content/test/image_decoder_test.h"
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/md5.h"
@@ skipping 33 matching lines @@
   memcpy(&contents->at(0), raw_image_data.data(), raw_image_data.size());
 }
 
 base::FilePath GetMD5SumPath(const base::FilePath& path) {
   static const base::FilePath::StringType kDecodedDataExtension(
       FILE_PATH_LITERAL(".md5sum"));
   return base::FilePath(path.value() + kDecodedDataExtension);
 }
 
 #if defined(CALCULATE_MD5_SUMS)
-void SaveMD5Sum(const base::FilePath& path, const WebKit::WebImage& web_image) {
+void SaveMD5Sum(const base::FilePath& path, const blink::WebImage& web_image) {
   // Calculate MD5 sum.
   base::MD5Digest digest;
   web_image.getSkBitmap().lockPixels();
   base::MD5Sum(web_image.getSkBitmap().getPixels(),
          web_image.getSkBitmap().width() * web_image.getSkBitmap().height() *
          sizeof(uint32_t),
          &digest);
 
   // Write sum to disk.
   int bytes_written = file_util::WriteFile(path,
       reinterpret_cast<const char*>(&digest), sizeof digest);
   ASSERT_EQ(sizeof digest, bytes_written);
   web_image.getSkBitmap().unlockPixels();
 }
 #endif
 
 #if !defined(CALCULATE_MD5_SUMS)
-void VerifyImage(const WebKit::WebImageDecoder& decoder,
+void VerifyImage(const blink::WebImageDecoder& decoder,
                  const base::FilePath& path,
                  const base::FilePath& md5_sum_path,
                  size_t frame_index) {
   // Make sure decoding can complete successfully.
   EXPECT_TRUE(decoder.isSizeAvailable()) << path.value();
   EXPECT_GE(decoder.frameCount(), frame_index) << path.value();
   EXPECT_TRUE(decoder.isFrameCompleteAtIndex(frame_index)) << path.value();
   EXPECT_FALSE(decoder.isFailed());
 
   // Calculate MD5 sum.
   base::MD5Digest actual_digest;
-  WebKit::WebImage web_image = decoder.getFrameAtIndex(frame_index);
+  blink::WebImage web_image = decoder.getFrameAtIndex(frame_index);
   web_image.getSkBitmap().lockPixels();
   base::MD5Sum(web_image.getSkBitmap().getPixels(),
          web_image.getSkBitmap().width() * web_image.getSkBitmap().height() *
          sizeof(uint32_t),
          &actual_digest);
 
   // Read the MD5 sum off disk.
   std::string file_bytes;
   base::ReadFileToString(md5_sum_path, &file_bytes);
   base::MD5Digest expected_digest;
@@ skipping 77 matching lines @@
   bool should_test_failed_images = true;
 #ifdef CALCULATE_MD5_SUMS
     // Do not test anything just get the md5 sums.
     should_test_chunking = false;
     should_test_failed_images = false;
 #endif
 
   std::vector<char> image_contents;
   ReadFileToVector(image_path, &image_contents);
   EXPECT_TRUE(image_contents.size());
-  scoped_ptr<WebKit::WebImageDecoder> decoder(CreateWebKitImageDecoder());
+  scoped_ptr<blink::WebImageDecoder> decoder(CreateWebKitImageDecoder());
   EXPECT_FALSE(decoder->isFailed());
 
   if (should_test_chunking) {
     // Test chunking file into half.
     const int partial_size = image_contents.size()/2;
 
-    WebKit::WebData partial_data(
+    blink::WebData partial_data(
       reinterpret_cast<const char*>(&(image_contents.at(0))), partial_size);
 
     // Make Sure the image decoder doesn't fail when we ask for the frame
     // buffer for this partial image.
     // NOTE: We can't check that frame 0 is non-NULL, because if this is an
     // ICO and we haven't yet supplied enough data to read the directory,
     // there is no framecount and thus no first frame.
-    decoder->setData(const_cast<WebKit::WebData&>(partial_data), false);
+    decoder->setData(const_cast<blink::WebData&>(partial_data), false);
     EXPECT_FALSE(decoder->isFailed()) << image_path.value();
   }
 
   // Make sure passing the complete image results in successful decoding.
-  WebKit::WebData data(reinterpret_cast<const char*>(&(image_contents.at(0))),
+  blink::WebData data(reinterpret_cast<const char*>(&(image_contents.at(0))),
     image_contents.size());
-  decoder->setData(const_cast<WebKit::WebData&>(data), true);
+  decoder->setData(const_cast<blink::WebData&>(data), true);
 
   if (should_test_failed_images) {
     if (ShouldImageFail(image_path)) {
       EXPECT_FALSE(decoder->isFrameCompleteAtIndex(kFirstFrameIndex));
       EXPECT_TRUE(decoder->isFailed());
          return;
     }
   }
 
   EXPECT_FALSE(decoder->isFailed()) << image_path.value();
 
 #ifdef CALCULATE_MD5_SUMS
   // Since WebImage does not expose get data by frame, get the size
   // through decoder and pass it to fromData so that the closest
   // image dats to the size is returned.
-  WebKit::WebSize size(decoder->getImage(desired_frame_index).size());
-  const WebKit::WebImage& image = WebKit::WebImage::fromData(data, size);
+  blink::WebSize size(decoder->getImage(desired_frame_index).size());
+  const blink::WebImage& image = blink::WebImage::fromData(data, size);
   SaveMD5Sum(md5_sum_path, image);
 #else
   VerifyImage(*decoder, image_path, md5_sum_path, desired_frame_index);
 #endif
 }