Remove implicit conversions from scoped_refptr to T* in win8/

win8/metro_driver/ime/text_service.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_service.h"
 
 #include <msctf.h>
 
 #include "base/logging.h"
 #include "base/win/scoped_variant.h"
@@ skipping 158 matching lines @@
 }
 
 // A class that manages the lifetime of the event callback registration. When
 // this object is destroyed, corresponding event callback will be unregistered.
 class EventSink {
  public:
   EventSink(DWORD cookie, base::win::ScopedComPtr<ITfSource> source)
       : cookie_(cookie),
         source_(source) {}
   ~EventSink() {
-    if (!source_ || cookie_ != TF_INVALID_COOKIE)
+    if (!source_.get() || cookie_ != TF_INVALID_COOKIE)
       return;
     source_->UnadviseSink(cookie_);
     cookie_ = TF_INVALID_COOKIE;
     source_.Release();
   }
 
  private:
   DWORD cookie_;
   base::win::ScopedComPtr<ITfSource> source_;
   DISALLOW_COPY_AND_ASSIGN(EventSink);
@@ skipping 21 matching lines @@
 // are maintained.
 //  - TextStore: a COM object that abstracts text buffer. This object is
 //      actually implemented by us in text_store.cc
 //  - ITfDocumentMgr: a focusable unit in TSF. This object is implemented by
 //      TSF runtime and works as a container of TextStore.
 //  - EventSink: an object that ensures that the event callback between
 //      TSF runtime and TextStore is unregistered when this object is destroyed.
 class DocumentBinding {
  public:
   ~DocumentBinding() {
-    if (!document_manager_)
+    if (!document_manager_.get())
       return;
     document_manager_->Pop(TF_POPF_ALL);
   }
 
   static scoped_ptr<DocumentBinding> Create(
       ITfThreadMgr* thread_manager,
       TfClientId client_id,
       const std::vector<InputScope>& input_scopes,
       HWND window_handle,
       TextStoreDelegate* delegate) {
     base::win::ScopedComPtr<ITfDocumentMgr> document_manager;
     HRESULT hr = thread_manager->CreateDocumentMgr(document_manager.Receive());
     if (FAILED(hr)) {
       LOG(ERROR) << "ITfThreadMgr::CreateDocumentMgr failed. hr = " << hr;
       return scoped_ptr<DocumentBinding>();
     }
 
     // Note: In our IPC protocol, an empty |input_scopes| is used to indicate
     // that an IME must be disabled in this context. In such case, we need not
     // instantiate TextStore.
     const bool use_null_text_store = input_scopes.empty();
 
     scoped_refptr<TextStore> text_store;
     if (!use_null_text_store) {
       text_store = TextStore::Create(window_handle, input_scopes, delegate);
-      if (!text_store) {
+      if (!text_store.get()) {
         LOG(ERROR) << "Failed to create TextStore.";
         return scoped_ptr<DocumentBinding>();
       }
     }
 
     base::win::ScopedComPtr<ITfContext> context;
     DWORD edit_cookie = TF_INVALID_EDIT_COOKIE;
     hr = document_manager->CreateContext(
         client_id,
         0,
         static_cast<ITextStoreACP*>(text_store.get()),
         context.Receive(),
         &edit_cookie);
     if (FAILED(hr)) {
       LOG(ERROR) << "ITfDocumentMgr::CreateContext failed. hr = " << hr;
       return scoped_ptr<DocumentBinding>();
     }
 
     // If null-TextStore is used or |input_scopes| looks like a password field,
     // set special properties to tell IMEs to be disabled.
     if ((use_null_text_store || IsPasswordField(input_scopes)) &&
-        !InitializeDisabledContext(context, client_id)) {
+        !InitializeDisabledContext(context.get(), client_id)) {
       LOG(ERROR) << "InitializeDisabledContext failed.";
       return scoped_ptr<DocumentBinding>();
     }
 
     scoped_ptr<EventSink> text_edit_sink;
     if (!use_null_text_store) {
-      text_edit_sink = CreateTextEditSink(context, text_store);
+      text_edit_sink = CreateTextEditSink(context.get(), text_store.get());
       if (!text_edit_sink) {
         LOG(ERROR) << "CreateTextEditSink failed.";
         return scoped_ptr<DocumentBinding>();
       }
     }
-    hr = document_manager->Push(context);
+    hr = document_manager->Push(context.get());
     if (FAILED(hr)) {
       LOG(ERROR) << "ITfDocumentMgr::Push failed. hr = " << hr;
       return scoped_ptr<DocumentBinding>();
     }
     return scoped_ptr<DocumentBinding>(
         new DocumentBinding(text_store,
                             document_manager,
                             text_edit_sink.Pass()));
   }
 
-  ITfDocumentMgr* document_manager() const {
-    return document_manager_;
-  }
+  ITfDocumentMgr* document_manager() const { return document_manager_.get(); }
 
   scoped_refptr<TextStore> text_store() const {
     return text_store_;
   }
 
  private:
   DocumentBinding(scoped_refptr<TextStore> text_store,
                   base::win::ScopedComPtr<ITfDocumentMgr> document_manager,
                   scoped_ptr<EventSink> text_edit_sink)
       : text_store_(text_store),
@@ skipping 13 matching lines @@
   TextServiceImpl(ITfThreadMgr* thread_manager,
                   TfClientId client_id,
                   HWND window_handle,
                   TextServiceDelegate* delegate)
       : client_id_(client_id),
         window_handle_(window_handle),
         delegate_(delegate),
         thread_manager_(thread_manager) {
     DCHECK_NE(TF_CLIENTID_NULL, client_id);
     DCHECK(window_handle != NULL);
-    DCHECK(thread_manager_);
+    DCHECK(thread_manager_.get());
   }
   virtual ~TextServiceImpl() {
     thread_manager_->Deactivate();
   }
 
  private:
   // TextService overrides:
   virtual void CancelComposition() override {
     if (!current_document_) {
       VLOG(0) << "|current_document_| is NULL due to the previous error.";
       return;
     }
-    TextStore* text_store = current_document_->text_store();
-    if (!text_store)
+    scoped_refptr<TextStore> text_store = current_document_->text_store();
+    if (!text_store.get())
       return;
     text_store->CancelComposition();
   }
 
   virtual void OnDocumentChanged(
       const std::vector<int32>& input_scopes,
       const std::vector<metro_viewer::CharacterBounds>& character_bounds)
       override {
     bool document_type_changed = input_scopes_ != input_scopes;
     input_scopes_ = input_scopes;
@@ skipping 118 matching lines @@
     LOG(ERROR) << "Failed to create instance of CLSID_TF_ThreadMgr. hr = "
                << hr;
     return scoped_ptr<TextService>();
   }
   TfClientId client_id = TF_CLIENTID_NULL;
   hr = thread_manager->Activate(&client_id);
   if (FAILED(hr)) {
     LOG(ERROR) << "ITfThreadMgr::Activate failed. hr = " << hr;
     return scoped_ptr<TextService>();
   }
-  if (!InitializeSentenceMode(thread_manager, client_id)) {
+  if (!InitializeSentenceMode(thread_manager.get(), client_id)) {
     LOG(ERROR) << "InitializeSentenceMode failed.";
     thread_manager->Deactivate();
     return scoped_ptr<TextService>();
   }
-  return scoped_ptr<TextService>(new TextServiceImpl(thread_manager,
-                                                     client_id,
-                                                     window_handle,
-                                                     delegate));
+  return scoped_ptr<TextService>(new TextServiceImpl(
+      thread_manager.get(), client_id, window_handle, delegate));
 }
 
 }  // namespace metro_driver