Remove implicit conversions from scoped_refptr to T* in win8/

win8/metro_driver/ime/text_store.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 "win8/metro_driver/ime/text_store.h"
 
 #include <algorithm>
 
 #include "base/win/scoped_variant.h"
 #include "ui/base/win/atl_module.h"
@@ skipping 41 matching lines @@
     return scoped_refptr<TextStore>();
   }
   base::win::ScopedComPtr<ITfDisplayAttributeMgr> display_attribute_manager;
   hr = display_attribute_manager.CreateInstance(CLSID_TF_DisplayAttributeMgr);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to initialize DisplayAttributeMgr. hr = " << hr;
     return scoped_refptr<TextStore>();
   }
   base::win::ScopedComPtr<ITfInputScope> input_scope =
       CreteInputScope(input_scopes);
-  if (!input_scope) {
+  if (!input_scope.get()) {
     LOG(ERROR) << "Failed to initialize InputScope.";
     return scoped_refptr<TextStore>();
   }
 
   ui::win::CreateATLModuleIfNeeded();
   CComObject<TextStore>* object = NULL;
   hr = CComObject<TextStore>::CreateInstance(&object);
   if (FAILED(hr)) {
     LOG(ERROR) << "CComObject<TextStore>::CreateInstance failed. hr = "
                << hr;
     return scoped_refptr<TextStore>();
   }
-  object->Initialize(window_handle,
-                     category_manager,
-                     display_attribute_manager,
-                     input_scope,
+  object->Initialize(window_handle, category_manager.get(),
+                     display_attribute_manager.get(), input_scope.get(),
                      delegate);
   return scoped_refptr<TextStore>(object);
 }
 
 void TextStore::Initialize(HWND window_handle,
                            ITfCategoryMgr* category_manager,
                            ITfDisplayAttributeMgr* display_attribute_manager,
                            ITfInputScope* input_scope,
                            TextStoreDelegate* delegate) {
   window_handle_ = window_handle;
   category_manager_ = category_manager;
   display_attribute_manager_ = display_attribute_manager;
   input_scope_ = input_scope;
   delegate_ = delegate;
 }
 
 
 STDMETHODIMP TextStore::AdviseSink(REFIID iid,
                                    IUnknown* unknown,
                                    DWORD mask) {
   if (!IsEqualGUID(iid, IID_ITextStoreACPSink))
     return E_INVALIDARG;
-  if (text_store_acp_sink_) {
+  if (text_store_acp_sink_.get()) {
     if (text_store_acp_sink_.IsSameObject(unknown)) {
       text_store_acp_sink_mask_ = mask;
       return S_OK;
     } else {
       return CONNECT_E_ADVISELIMIT;
     }
   }
   if (FAILED(text_store_acp_sink_.QueryFrom(unknown)))
     return E_UNEXPECTED;
   text_store_acp_sink_mask_ = mask;
@@ skipping 462 matching lines @@
 
   return S_OK;
 }
 
 STDMETHODIMP TextStore::RequestSupportedAttrs(
     DWORD /* flags */,  // Seems that we should ignore this.
     ULONG attribute_buffer_size,
     const TS_ATTRID* attribute_buffer) {
   if (!attribute_buffer)
     return E_INVALIDARG;
-  if (!input_scope_)
+  if (!input_scope_.get())
     return E_FAIL;
   // We support only input scope attribute.
   for (size_t i = 0; i < attribute_buffer_size; ++i) {
     if (IsEqualGUID(GUID_PROP_INPUTSCOPE, attribute_buffer[i]))
       return S_OK;
   }
   return E_FAIL;
 }
 
 STDMETHODIMP TextStore::RetrieveRequestedAttrs(
     ULONG attribute_buffer_size,
     TS_ATTRVAL* attribute_buffer,
     ULONG* attribute_buffer_copied) {
   if (!attribute_buffer_copied)
     return E_INVALIDARG;
   *attribute_buffer_copied = 0;
   if (!attribute_buffer)
     return E_INVALIDARG;
-  if (!input_scope_)
+  if (!input_scope_.get())
     return E_UNEXPECTED;
   // We support only input scope attribute.
   *attribute_buffer_copied = 0;
   if (attribute_buffer_size == 0)
     return S_OK;
 
   attribute_buffer[0].dwOverlapId = 0;
   attribute_buffer[0].idAttr = GUID_PROP_INPUTSCOPE;
   attribute_buffer[0].varValue.vt = VT_UNKNOWN;
   attribute_buffer[0].varValue.punkVal = input_scope_.get();
@@ skipping 130 matching lines @@
   *committed_size = 0;
   undelines->clear();
   base::win::ScopedComPtr<ITfRange> start_to_end_range;
   base::win::ScopedComPtr<ITfRange> end_range;
   if (FAILED(context->GetStart(read_only_edit_cookie,
                                start_to_end_range.Receive()))) {
     return false;
   }
   if (FAILED(context->GetEnd(read_only_edit_cookie, end_range.Receive())))
     return false;
-  if (FAILED(start_to_end_range->ShiftEndToRange(read_only_edit_cookie,
-                                                 end_range, TF_ANCHOR_END))) {
+  if (FAILED(start_to_end_range->ShiftEndToRange(
+          read_only_edit_cookie, end_range.get(), TF_ANCHOR_END))) {
     return false;
   }
 
   base::win::ScopedComPtr<IEnumTfRanges> ranges;
   if (FAILED(track_property->EnumRanges(read_only_edit_cookie, ranges.Receive(),
-                                        start_to_end_range))) {
+                                        start_to_end_range.get()))) {
     return false;
   }
 
   while (true) {
     base::win::ScopedComPtr<ITfRange> range;
     if (ranges->Next(1, range.Receive(), NULL) != S_OK)
       return true;
     base::win::ScopedVariant value;
     base::win::ScopedComPtr<IEnumTfPropertyValue> enum_prop_value;
-    if (FAILED(track_property->GetValue(read_only_edit_cookie, range,
+    if (FAILED(track_property->GetValue(read_only_edit_cookie, range.get(),
                                         value.Receive()))) {
       return false;
     }
     if (FAILED(enum_prop_value.QueryFrom(value.AsInput()->punkVal)))
       return false;
 
     TF_PROPERTYVAL property_value;
     bool is_composition = false;
     metro_viewer::UnderlineInfo underline;
     while (enum_prop_value->Next(1, &property_value, NULL) == S_OK) {
       if (IsEqualGUID(property_value.guidId, GUID_PROP_COMPOSING)) {
         is_composition = (property_value.varValue.lVal == TRUE);
       } else if (IsEqualGUID(property_value.guidId, GUID_PROP_ATTRIBUTE)) {
         TfGuidAtom guid_atom =
             static_cast<TfGuidAtom>(property_value.varValue.lVal);
         TF_DISPLAYATTRIBUTE display_attribute;
         if (GetDisplayAttribute(guid_atom, &display_attribute))
           underline.thick = !!display_attribute.fBoldLine;
       }
       VariantClear(&property_value.varValue);
     }
 
     base::win::ScopedComPtr<ITfRangeACP> range_acp;
-    range_acp.QueryFrom(range);
+    range_acp.QueryFrom(range.get());
     LONG start_pos, length;
     range_acp->GetExtent(&start_pos, &length);
     if (is_composition) {
       underline.start_offset = start_pos;
       underline.end_offset = start_pos + length;
       undelines->push_back(underline);
     } else if (*committed_size < static_cast<size_t>(start_pos + length)) {
       *committed_size = start_pos + length;
     }
   }
@@ skipping 66 matching lines @@
     TS_TEXTCHANGE textChange = {};
     textChange.acpStart = 0;
     textChange.acpOldEnd = previous_buffer_size;
     textChange.acpNewEnd = 0;
     text_store_acp_sink_->OnTextChange(0, &textChange);
   }
   return true;
 }
 
 void TextStore::SendOnLayoutChange() {
-  if (text_store_acp_sink_ && (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE))
+  if (text_store_acp_sink_.get() &&
+      (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE)) {
     text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0);
+  }
 }
 
 bool TextStore::HasReadLock() const {
   return (current_lock_type_ & TS_LF_READ) == TS_LF_READ;
 }
 
 bool TextStore::HasReadWriteLock() const {
   return (current_lock_type_ & TS_LF_READWRITE) == TS_LF_READWRITE;
 }
 
 }  // namespace metro_driver