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

content/browser/fileapi/fileapi_message_filter.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/browser/fileapi/fileapi_message_filter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
     int process_id,
     net::URLRequestContextGetter* request_context_getter,
     fileapi::FileSystemContext* file_system_context,
     ChromeBlobStorageContext* blob_storage_context)
     : process_id_(process_id),
       context_(file_system_context),
       request_context_getter_(request_context_getter),
       request_context_(NULL),
       blob_storage_context_(blob_storage_context) {
   DCHECK(context_);
-  DCHECK(request_context_getter_);
+  DCHECK(request_context_getter_.get());
   DCHECK(blob_storage_context);
 }
 
 FileAPIMessageFilter::FileAPIMessageFilter(
     int process_id,
     net::URLRequestContext* request_context,
     fileapi::FileSystemContext* file_system_context,
     ChromeBlobStorageContext* blob_storage_context)
     : process_id_(process_id),
       context_(file_system_context),
       request_context_(request_context),
       blob_storage_context_(blob_storage_context) {
   DCHECK(context_);
   DCHECK(request_context_);
   DCHECK(blob_storage_context);
 }
 
 void FileAPIMessageFilter::OnChannelConnected(int32 peer_pid) {
   BrowserMessageFilter::OnChannelConnected(peer_pid);
 
-  if (request_context_getter_) {
+  if (request_context_getter_.get()) {
     DCHECK(!request_context_);
     request_context_ = request_context_getter_->GetURLRequestContext();
     request_context_getter_ = NULL;
     DCHECK(request_context_);
   }
 }
 
 void FileAPIMessageFilter::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
 
@@ skipping 645 matching lines @@
     // that the renderer can read the file's platform path. If this is the case
     // the renderer should be granted read permission for the file's platform
     // path. This can happen in the following situations:
     // - the file comes from sandboxed filesystem. Reading sandboxed files is
     //   always permitted, but only implicitly.
     // - the underlying filesystem returned newly created snapshot file.
     // - the nominal path differs from the platform path. This can happen even
     //   when the filesystem has been granted permissions. This happens with:
     //   - Drive filesystems
     //   - Picasa filesystems
-    DCHECK(snapshot_file ||
+    DCHECK(snapshot_file.get() ||
            fileapi::SandboxMountPointProvider::IsSandboxType(url.type()) ||
            url.type() == fileapi::kFileSystemTypeDrive ||
            url.type() == fileapi::kFileSystemTypePicasa);
     ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
         process_id_, platform_path);
-    if (snapshot_file) {
+    if (snapshot_file.get()) {
       // This will revoke all permissions for the file when the last ref
       // of the file is dropped (assuming it's ok).
       snapshot_file->AddFinalReleaseCallback(
           base::Bind(&RevokeFilePermission, process_id_));
     }
   }
 
-  if (snapshot_file) {
+  if (snapshot_file.get()) {
     // This ref is held until OnDidReceiveSnapshotFile is called.
     in_transit_snapshot_files_[request_id] = snapshot_file;
   }
 
   // Return the file info and platform_path.
   Send(new FileSystemMsg_DidCreateSnapshotFile(
                request_id, info, platform_path));
 }
 
 bool FileAPIMessageFilter::HasPermissionsForFile(
@@ skipping 12 matching lines @@
     Send(new FileSystemMsg_DidFail(request_id, error_code));
     return NULL;
   }
 
   DCHECK(operation);
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 }  // namespace content