Remove implicit conversions from scoped_refptr to T* in win8/

win8/test/ui_automation_client.cc

 // Copyright (c) 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 "win8/test/ui_automation_client.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <oleauto.h>
 #include <uiautomation.h>
@@ skipping 231 matching lines @@
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
   event_handler_obj->Initialize(base::ThreadTaskRunnerHandle::Get(),
                                 weak_ptr_factory_.GetWeakPtr());
   base::win::ScopedComPtr<IUIAutomationEventHandler> event_handler(
       event_handler_obj);
 
   result = automation_->AddAutomationEventHandler(
-      UIA_Window_WindowOpenedEventId,
-      root_element,
-      TreeScope_Descendants,
-      cache_request,
-      event_handler);
+      UIA_Window_WindowOpenedEventId, root_element.get(), TreeScope_Descendants,
+      cache_request.get(), event_handler.get());
 
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   event_handler_ = event_handler;
   return S_OK;
 }
 
 // Removes this instance's window observer.
 HRESULT UIAutomationClient::Context::RemoveWindowObserver() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(automation_.get());
   DCHECK(event_handler_.get());
 
   HRESULT result = S_OK;
   base::win::ScopedComPtr<IUIAutomationElement> root_element;
 
   // The opening of all windows are observed.
   result = automation_->GetRootElement(root_element.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   result = automation_->RemoveAutomationEventHandler(
-      UIA_Window_WindowOpenedEventId,
-      root_element,
-      event_handler_);
+      UIA_Window_WindowOpenedEventId, root_element.get(), event_handler_.get());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   event_handler_ = NULL;
   return S_OK;
 }
 
 // Handles an automation event. If the event results in the processing for which
@@ skipping 119 matching lines @@
   // Cache invokable pattern for the item.
   result = automation_->CreateCacheRequest(cache_request.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
   cache_request->AddPattern(UIA_InvokePatternId);
 
   result = element->FindFirstBuildCache(
       static_cast<TreeScope>(TreeScope_Children | TreeScope_Descendants),
-      condition,
-      cache_request,
-      target.Receive());
+      condition.get(), cache_request.get(), target.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   // If the item was found, invoke it.
   if (!target.get()) {
     LOG(WARNING) << "Failed to find desired item to invoke.";
     return E_FAIL;
   }
@@ skipping 43 matching lines @@
     return result;
   }
 
   result = automation_->get_ControlViewCondition(
       control_view_condition.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
-  result = automation_->CreateAndCondition(
-      invokable_condition, control_view_condition, condition.Receive());
+  result = automation_->CreateAndCondition(invokable_condition.get(),
+                                           control_view_condition.get(),
+                                           condition.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   // Cache item names.
   result = automation_->CreateCacheRequest(cache_request.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
   cache_request->AddProperty(UIA_NamePropertyId);
 
   result = element->FindAllBuildCache(
       static_cast<TreeScope>(TreeScope_Children | TreeScope_Descendants),
-      condition,
-      cache_request,
-      element_array.Receive());
+      condition.get(), cache_request.get(), element_array.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   if (!element_array.get()) {
     LOG(ERROR) << "The window may have vanished.";
     return S_OK;
   }
 
@@ skipping 97 matching lines @@
                  context_,
                  base::ThreadTaskRunnerHandle::Get(),
                  base::string16(class_name),
                  item_name,
                  init_callback,
                  result_callback));
 }
 
 }  // namespace internal
 }  // namespace win8