Rename WebKit namespace to blink (part 3)

content/child/fileapi/webfilewriter_base_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 "content/child/fileapi/webfilewriter_base.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 21 matching lines @@
 const int kCancelFileWriteAfterCompletion_Offset = 5;
 
 GURL mock_path_as_gurl() {
   return GURL("MockPath");
 }
 
 }  // namespace
 
 class TestableFileWriter : public WebFileWriterBase {
  public:
-  explicit TestableFileWriter(WebKit::WebFileWriterClient* client)
+  explicit TestableFileWriter(blink::WebFileWriterClient* client)
       : WebFileWriterBase(mock_path_as_gurl(), client) {
     reset();
   }
 
   void reset() {
     received_truncate_ = false;
     received_truncate_path_ = GURL();
     received_truncate_offset_ = kNoOffset;
     received_write_ = false;
     received_write_path_ = GURL();
@@ skipping 68 matching lines @@
       FAIL();
     }
   }
 
   virtual void DoCancel() OVERRIDE {
     received_cancel_ = true;
   }
 };
 
 class FileWriterTest : public testing::Test,
-                       public WebKit::WebFileWriterClient {
+                       public blink::WebFileWriterClient {
  public:
   FileWriterTest() {
     reset();
   }
 
-  WebKit::WebFileWriter* writer() {
+  blink::WebFileWriter* writer() {
     return testable_writer_.get();
   }
 
   // WebFileWriterClient overrides
   virtual void didWrite(long long bytes, bool complete) {
     EXPECT_FALSE(received_did_write_complete_);
     ++received_did_write_count_;
     received_did_write_bytes_total_ += bytes;
     if (complete)
       received_did_write_complete_ = true;
 
     if (delete_in_client_callback_)
       testable_writer_.reset(NULL);
   }
 
   virtual void didTruncate() {
     EXPECT_FALSE(received_did_truncate_);
     received_did_truncate_ = true;
     if (delete_in_client_callback_)
       testable_writer_.reset(NULL);
   }
 
-  virtual void didFail(WebKit::WebFileError error) {
+  virtual void didFail(blink::WebFileError error) {
     EXPECT_FALSE(received_did_fail_);
     received_did_fail_ = true;
     fail_error_received_ = error;
     if (delete_in_client_callback_)
       testable_writer_.reset(NULL);
   }
 
  protected:
   void reset() {
     testable_writer_.reset(new TestableFileWriter(this));
     delete_in_client_callback_ = false;
     received_did_write_count_ = 0;
     received_did_write_bytes_total_ = 0;
     received_did_write_complete_ = false;
     received_did_truncate_ = false;
     received_did_fail_ = false;
-    fail_error_received_ = static_cast<WebKit::WebFileError>(0);
+    fail_error_received_ = static_cast<blink::WebFileError>(0);
   }
 
   scoped_ptr<TestableFileWriter> testable_writer_;
   bool delete_in_client_callback_;
 
   // Observed WebFileWriterClient artifacts.
   int received_did_write_count_;
   long long received_did_write_bytes_total_;
   bool received_did_write_complete_;
   bool received_did_truncate_;
   bool received_did_fail_;
-  WebKit::WebFileError fail_error_received_;
+  blink::WebFileError fail_error_received_;
 
   DISALLOW_COPY_AND_ASSIGN(FileWriterTest);
 };
 
 TEST_F(FileWriterTest, BasicFileWrite) {
   // Call the webkit facing api.
   const std::string kBlobId("1234");
   writer()->write(kBasicFileWrite_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kBasicFileWrite_Offset,
             testable_writer_->received_write_offset_);
   EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_);
   EXPECT_FALSE(testable_writer_->received_truncate_);
   EXPECT_FALSE(testable_writer_->received_cancel_);
@@ skipping 22 matching lines @@
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_truncate_);
   EXPECT_EQ(0, received_did_write_count_);
   EXPECT_FALSE(received_did_fail_);
 }
 
 TEST_F(FileWriterTest, ErrorFileWrite) {
   // Call the webkit facing api.
   const std::string kBlobId("1234");
   writer()->write(kErrorFileWrite_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kErrorFileWrite_Offset,
             testable_writer_->received_write_offset_);
   EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_);
   EXPECT_FALSE(testable_writer_->received_truncate_);
   EXPECT_FALSE(testable_writer_->received_cancel_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorNotFound, fail_error_received_);
   EXPECT_EQ(0, received_did_write_count_);
   EXPECT_FALSE(received_did_truncate_);
 }
 
 TEST_F(FileWriterTest, ErrorFileTruncate) {
   // Call the webkit facing api.
   writer()->truncate(kErrorFileTruncate_Offset);
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_truncate_);
   EXPECT_EQ(mock_path_as_gurl(),
             testable_writer_->received_truncate_path_);
   EXPECT_EQ(kErrorFileTruncate_Offset,
             testable_writer_->received_truncate_offset_);
   EXPECT_FALSE(testable_writer_->received_write_);
   EXPECT_FALSE(testable_writer_->received_cancel_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorNotFound, fail_error_received_);
   EXPECT_FALSE(received_did_truncate_);
   EXPECT_EQ(0, received_did_write_count_);
 }
 
 TEST_F(FileWriterTest, MultiFileWrite) {
   // Call the webkit facing api.
   const std::string kBlobId("1234");
   writer()->write(kMultiFileWrite_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kMultiFileWrite_Offset,
             testable_writer_->received_write_offset_);
   EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_);
   EXPECT_FALSE(testable_writer_->received_truncate_);
   EXPECT_FALSE(testable_writer_->received_cancel_);
 
   // Check that the client gets called correctly.
   EXPECT_EQ(3, received_did_write_count_);
   EXPECT_TRUE(received_did_write_complete_);
   EXPECT_EQ(3, received_did_write_bytes_total_);
   EXPECT_FALSE(received_did_truncate_);
   EXPECT_FALSE(received_did_fail_);
 }
 
 TEST_F(FileWriterTest, CancelFileWriteBeforeCompletion) {
   // Call the webkit facing api.
   const std::string kBlobId("1234");
   writer()->write(kCancelFileWriteBeforeCompletion_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kCancelFileWriteBeforeCompletion_Offset,
             testable_writer_->received_write_offset_);
   EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_);
   EXPECT_TRUE(testable_writer_->received_cancel_);
   EXPECT_FALSE(testable_writer_->received_truncate_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_);
   EXPECT_EQ(1, received_did_write_count_);
   EXPECT_FALSE(received_did_write_complete_);
   EXPECT_EQ(1, received_did_write_bytes_total_);
   EXPECT_FALSE(received_did_truncate_);
 }
 
 TEST_F(FileWriterTest, CancelFileWriteAfterCompletion) {
   // Call the webkit facing api.
   const std::string kBlobId("1234");
   writer()->write(kCancelFileWriteAfterCompletion_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kCancelFileWriteAfterCompletion_Offset,
             testable_writer_->received_write_offset_);
   EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_);
   EXPECT_TRUE(testable_writer_->received_cancel_);
   EXPECT_FALSE(testable_writer_->received_truncate_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_);
   EXPECT_EQ(1, received_did_write_count_);
   EXPECT_FALSE(received_did_write_complete_);
   EXPECT_EQ(1, received_did_write_bytes_total_);
   EXPECT_FALSE(received_did_truncate_);
 }
 
 TEST_F(FileWriterTest, CancelFileTruncate) {
   // Call the webkit facing api.
   writer()->truncate(kCancelFileTruncate_Offset);
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_truncate_);
   EXPECT_EQ(mock_path_as_gurl(),
             testable_writer_->received_truncate_path_);
   EXPECT_EQ(kCancelFileTruncate_Offset,
             testable_writer_->received_truncate_offset_);
   EXPECT_TRUE(testable_writer_->received_cancel_);
   EXPECT_FALSE(testable_writer_->received_write_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_);
   EXPECT_FALSE(received_did_truncate_);
   EXPECT_EQ(0, received_did_write_count_);
 }
 
 TEST_F(FileWriterTest, CancelFailedTruncate) {
   // Call the webkit facing api.
   writer()->truncate(kCancelFailedTruncate_Offset);
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_truncate_);
   EXPECT_EQ(mock_path_as_gurl(),
             testable_writer_->received_truncate_path_);
   EXPECT_EQ(kCancelFailedTruncate_Offset,
             testable_writer_->received_truncate_offset_);
   EXPECT_TRUE(testable_writer_->received_cancel_);
   EXPECT_FALSE(testable_writer_->received_write_);
 
   // Check that the client gets called correctly.
   EXPECT_TRUE(received_did_fail_);
-  EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_);
+  EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_);
   EXPECT_FALSE(received_did_truncate_);
   EXPECT_EQ(0, received_did_write_count_);
 }
 
 TEST_F(FileWriterTest, DeleteInCompletionCallbacks) {
   const std::string kBlobId("1234");
   delete_in_client_callback_ = true;
   writer()->write(kBasicFileWrite_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
   EXPECT_FALSE(testable_writer_.get());
 
   reset();
   delete_in_client_callback_ = true;
   writer()->truncate(kBasicFileTruncate_Offset);
   EXPECT_FALSE(testable_writer_.get());
 
   reset();
   delete_in_client_callback_ = true;
   writer()->write(kErrorFileWrite_Offset,
-                  WebKit::WebString::fromUTF8(kBlobId));
+                  blink::WebString::fromUTF8(kBlobId));
   EXPECT_FALSE(testable_writer_.get());
 
   reset();
   delete_in_client_callback_ = true;
   writer()->truncate(kErrorFileTruncate_Offset);
   EXPECT_FALSE(testable_writer_.get());
 
   // Not crashing counts as passing.
 }
 
 }  // namespace content