Update webkit/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

webkit/dom_storage/dom_storage_context_unittest.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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 25 matching lines @@
   const bool kDontIncludeFileInfo;
   const bool kDoIncludeFileInfo;
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     storage_policy_ = new quota::MockSpecialStoragePolicy;
     task_runner_ = new MockDomStorageTaskRunner(
             base::MessageLoopProxy::current());
     context_ = new DomStorageContext(temp_dir_.path(),
                                      base::FilePath(),
-                                     storage_policy_,
-                                     task_runner_);
+                                     storage_policy_.get(),
+                                     task_runner_.get());
   }
 
   virtual void TearDown() {
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void VerifySingleOriginRemains(const GURL& origin) {
     // Use a new instance to examine the contexts of temp_dir_.
     scoped_refptr<DomStorageContext> context =
         new DomStorageContext(temp_dir_.path(), base::FilePath(), NULL, NULL);
@@ skipping 127 matching lines @@
             cloned_dom_namespace->persistent_namespace_id());
   // Verify that the areas inherit the persistent ID.
   DomStorageArea* cloned_area = cloned_dom_namespace->OpenStorageArea(kOrigin);
   EXPECT_EQ(kClonedPersistentId, cloned_area->persistent_namespace_id_);
 }
 
 TEST_F(DomStorageContextTest, DeleteSessionStorage) {
   // Create a DomStorageContext which will save sessionStorage on disk.
   context_ = new DomStorageContext(temp_dir_.path(),
                                    temp_dir_.path(),
-                                   storage_policy_,
-                                   task_runner_);
+                                   storage_policy_.get(),
+                                   task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
   ASSERT_EQ(temp_dir_.path(), context_->sessionstorage_directory());
 
   // Write data.
   const int kSessionStorageNamespaceId = 1;
   const std::string kPersistentId = "persistent";
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   DomStorageNamespace* dom_namespace =
       context_->GetStorageNamespace(kSessionStorageNamespaceId);
   DomStorageArea* area = dom_namespace->OpenStorageArea(kOrigin);
   const base::string16 kKey(ASCIIToUTF16("foo"));
   const base::string16 kValue(ASCIIToUTF16("bar"));
   NullableString16 old_nullable_value;
   area->SetItem(kKey, kValue, &old_nullable_value);
   dom_namespace->CloseStorageArea(area);
 
   // Destroy and recreate the DomStorageContext.
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
-  context_ = new DomStorageContext(
-      temp_dir_.path(), temp_dir_.path(), storage_policy_, task_runner_);
+  context_ = new DomStorageContext(temp_dir_.path(),
+                                   temp_dir_.path(),
+                                   storage_policy_.get(),
+                                   task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Read the data back.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   NullableString16 read_value;
   read_value = area->GetItem(kKey);
   EXPECT_EQ(kValue, read_value.string());
   dom_namespace->CloseStorageArea(area);
 
   SessionStorageUsageInfo info;
   info.origin = kOrigin;
   info.persistent_namespace_id = kPersistentId;
   context_->DeleteSessionStorage(info);
 
   // Destroy and recreate again.
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
-  context_ = new DomStorageContext(
-      temp_dir_.path(), temp_dir_.path(), storage_policy_, task_runner_);
+  context_ = new DomStorageContext(temp_dir_.path(),
+                                   temp_dir_.path(),
+                                   storage_policy_.get(),
+                                   task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Now there should be no data.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   read_value = area->GetItem(kKey);
   EXPECT_TRUE(read_value.is_null());
   dom_namespace->CloseStorageArea(area);
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace dom_storage