Rename WebKit namespace to blink (part 3)

content/browser/indexed_db/indexed_db_factory_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/browser/indexed_db/indexed_db_factory.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 22 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(IndexedDBFactoryTest);
 };
 
 class MockIDBFactory : public IndexedDBFactory {
  public:
   MockIDBFactory() : IndexedDBFactory(NULL) {}
   scoped_refptr<IndexedDBBackingStore> TestOpenBackingStore(
       const GURL& origin,
       const base::FilePath& data_directory) {
-    WebKit::WebIDBCallbacks::DataLoss data_loss =
-        WebKit::WebIDBCallbacks::DataLossNone;
+    blink::WebIDBCallbacks::DataLoss data_loss =
+        blink::WebIDBCallbacks::DataLossNone;
     std::string data_loss_message;
     bool disk_full;
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin,
                          data_directory,
                          &data_loss,
                          &data_loss_message,
                          &disk_full);
-    EXPECT_EQ(WebKit::WebIDBCallbacks::DataLossNone, data_loss);
+    EXPECT_EQ(blink::WebIDBCallbacks::DataLossNone, data_loss);
     return backing_store;
   }
 
   void TestCloseBackingStore(IndexedDBBackingStore* backing_store) {
     CloseBackingStore(backing_store->origin_url());
   }
 
   void TestReleaseBackingStore(IndexedDBBackingStore* backing_store,
                                bool immediate) {
     ReleaseBackingStore(backing_store->origin_url(), immediate);
@@ skipping 116 matching lines @@
 
 class DiskFullFactory : public IndexedDBFactory {
  public:
   DiskFullFactory() : IndexedDBFactory(NULL) {}
 
  private:
   virtual ~DiskFullFactory() {}
   virtual scoped_refptr<IndexedDBBackingStore> OpenBackingStore(
       const GURL& origin_url,
       const base::FilePath& data_directory,
-      WebKit::WebIDBCallbacks::DataLoss* data_loss,
+      blink::WebIDBCallbacks::DataLoss* data_loss,
       std::string* data_loss_message,
       bool* disk_full) OVERRIDE {
     *disk_full = true;
     return scoped_refptr<IndexedDBBackingStore>();
   }
 };
 
 class LookingForQuotaErrorMockCallbacks : public IndexedDBCallbacks {
  public:
   LookingForQuotaErrorMockCallbacks()
       : IndexedDBCallbacks(NULL, 0, 0), error_called_(false) {}
   virtual void OnError(const IndexedDBDatabaseError& error) OVERRIDE {
     error_called_ = true;
-    EXPECT_EQ(WebKit::WebIDBDatabaseExceptionQuotaError, error.code());
+    EXPECT_EQ(blink::WebIDBDatabaseExceptionQuotaError, error.code());
   }
 
  private:
   virtual ~LookingForQuotaErrorMockCallbacks() { EXPECT_TRUE(error_called_); }
   bool error_called_;
 };
 
 TEST_F(IndexedDBFactoryTest, QuotaErrorOnDiskFull) {
   const GURL origin("http://localhost:81");
 
@@ skipping 75 matching lines @@
   // Now simulate shutdown, which should stop the timer.
   factory->ContextDestroyed();
   EXPECT_TRUE(store->HasOneRef());  // Local.
   EXPECT_FALSE(store->close_timer()->IsRunning());
   EXPECT_FALSE(factory->IsBackingStoreOpenForTesting(origin));
 }
 
 }  // namespace
 
 }  // namespace content