Style fix of TSFTextStoreTest

ui/base/ime/win/tsf_text_store_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 "ui/base/ime/win/tsf_text_store.h"
 
+#include "base/memory/ref_counted.h"
 #include "base/win/scoped_com_initializer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/gfx/rect.h"
 
 using testing::_;
 using testing::Invoke;
 using testing::Return;
 
 namespace ui {
-
 namespace {
 
 class MockTextInputClient : public TextInputClient {
  public:
   ~MockTextInputClient() {}
   MOCK_METHOD1(SetCompositionText, void(const ui::CompositionText&));
   MOCK_METHOD0(ConfirmCompositionText, void());
   MOCK_METHOD0(ClearCompositionText, void());
   MOCK_METHOD1(InsertText, void(const string16&));
   MOCK_METHOD2(InsertChar, void(char16, int));
@@ skipping 12 matching lines @@
   MOCK_METHOD2(GetTextFromRange, bool(const gfx::Range&, string16*));
   MOCK_METHOD0(OnInputMethodChanged, void());
   MOCK_METHOD1(ChangeTextDirectionAndLayoutAlignment,
                bool(base::i18n::TextDirection));
   MOCK_METHOD2(ExtendSelectionAndDelete, void(size_t, size_t));
   MOCK_METHOD1(EnsureCaretInRect, void(const gfx::Rect&));
 };
 
 class MockStoreACPSink : public ITextStoreACPSink {
  public:
-  MockStoreACPSink() : ref_count_(0) {
-  }
+  MockStoreACPSink() : ref_count_(0) {}
 
   // IUnknown
   virtual ULONG STDMETHODCALLTYPE AddRef() OVERRIDE {
     return InterlockedIncrement(&ref_count_);
   }
   virtual ULONG STDMETHODCALLTYPE Release() OVERRIDE {
     const LONG count = InterlockedDecrement(&ref_count_);
     if (!count) {
       delete this;
       return 0;
@@ skipping 24 matching lines @@
   MOCK_METHOD4_WITH_CALLTYPE(STDMETHODCALLTYPE, OnAttrsChange,
                              HRESULT(LONG, LONG, ULONG, const TS_ATTRID*));
   MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, OnLockGranted,
                              HRESULT(DWORD));
   MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, OnStartEditTransaction,
                              HRESULT());
   MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, OnEndEditTransaction,
                              HRESULT());
 
  private:
-  ~MockStoreACPSink() {
-  }
+  virtual ~MockStoreACPSink() {}
 
   volatile LONG ref_count_;
 };
 
+const HWND kWindowHandle = reinterpret_cast<HWND>(1);
+
 }  // namespace
 
 class TSFTextStoreTest : public testing::Test {
  protected:
   virtual void SetUp() OVERRIDE {
     text_store_ = new TSFTextStore();
-    text_store_->AddRef();
     sink_ = new MockStoreACPSink();
-    sink_->AddRef();
     EXPECT_EQ(S_OK, text_store_->AdviseSink(IID_ITextStoreACPSink,
                                             sink_, TS_AS_ALL_SINKS));
-    text_store_->SetFocusedTextInputClient(0, &text_input_client_);
+    text_store_->SetFocusedTextInputClient(kWindowHandle,
+                                           &text_input_client_);
   }
 
   virtual void TearDown() OVERRIDE {
     EXPECT_EQ(S_OK, text_store_->UnadviseSink(sink_));
-    sink_->Release();
-    text_store_->Release();
+    sink_ = NULL;
+    text_store_ = NULL;
   }
 
   base::win::ScopedCOMInitializer com_initializer_;
   MockTextInputClient text_input_client_;
-  TSFTextStore* text_store_;
-  MockStoreACPSink* sink_;
+  scoped_refptr<TSFTextStore> text_store_;
+  scoped_refptr<MockStoreACPSink> sink_;
 };
 
 class TSFTextStoreTestCallback {
  public:
   explicit TSFTextStoreTestCallback(TSFTextStore* text_store)
       : text_store_(text_store) {
     CHECK(text_store_);
   }
   virtual ~TSFTextStoreTestCallback() {}
 
@@ skipping 17 matching lines @@
     *string_buffer() = new_string_buffer;
     *committed_size() = new_committed_size;
     selection()->set_start(new_selection_start);
     selection()->set_end(new_selection_end);
   }
 
   bool HasReadLock() const { return text_store_->HasReadLock(); }
   bool HasReadWriteLock() const { return text_store_->HasReadWriteLock(); }
 
   void GetSelectionTest(LONG expected_acp_start, LONG expected_acp_end) {
-    TS_SELECTION_ACP selection;
-    ULONG fetched;
+    TS_SELECTION_ACP selection = {};
+    ULONG fetched = 0;
     EXPECT_EQ(S_OK, text_store_->GetSelection(0, 1, &selection, &fetched));
     EXPECT_EQ(1, fetched);
     EXPECT_EQ(expected_acp_start, selection.acpStart);
     EXPECT_EQ(expected_acp_end, selection.acpEnd);
   }
 
   void SetSelectionTest(LONG acp_start, LONG acp_end, HRESULT expected_result) {
-    TS_SELECTION_ACP selection;
+    TS_SELECTION_ACP selection = {};
     selection.acpStart = acp_start;
     selection.acpEnd = acp_end;
     selection.style.ase = TS_AE_NONE;
     selection.style.fInterimChar = 0;
     EXPECT_EQ(expected_result, text_store_->SetSelection(1, &selection));
     if (expected_result == S_OK) {
       GetSelectionTest(acp_start, acp_end);
     }
   }
 
   void SetTextTest(LONG acp_start, LONG acp_end,
                    const string16& text, HRESULT error_code) {
-    TS_TEXTCHANGE change;
+    TS_TEXTCHANGE change = {};
     ASSERT_EQ(error_code,
               text_store_->SetText(0, acp_start, acp_end,
                                    text.c_str(), text.size(), &change));
     if (error_code == S_OK) {
       EXPECT_EQ(acp_start, change.acpStart);
       EXPECT_EQ(acp_end, change.acpOldEnd);
       EXPECT_EQ(acp_start + text.size(), change.acpNewEnd);
     }
   }
 
   void GetTextTest(LONG acp_start, LONG acp_end,
                    const string16& expected_string,
                    LONG expected_next_acp) {
-    wchar_t buffer[1024];
-    ULONG text_buffer_copied;
-    TS_RUNINFO run_info;
-    ULONG run_info_buffer_copied;
-    LONG next_acp;
+    wchar_t buffer[1024] = {};
+    ULONG text_buffer_copied = 0;
+    TS_RUNINFO run_info = {};
+    ULONG run_info_buffer_copied = 0;
+    LONG next_acp = 0;
     ASSERT_EQ(S_OK,
               text_store_->GetText(acp_start, acp_end, buffer, 1024,
                                    &text_buffer_copied,
                                    &run_info, 1, &run_info_buffer_copied,
                                    &next_acp));
     ASSERT_EQ(expected_string.size(), text_buffer_copied);
     EXPECT_EQ(expected_string, string16(buffer, buffer + text_buffer_copied));
     EXPECT_EQ(1, run_info_buffer_copied);
     EXPECT_EQ(expected_string.size(), run_info.uCount);
     EXPECT_EQ(TS_RT_PLAIN, run_info.type);
     EXPECT_EQ(expected_next_acp, next_acp);
   }
 
   void GetTextErrorTest(LONG acp_start, LONG acp_end, HRESULT error_code) {
-    wchar_t buffer[1024];
-    ULONG text_buffer_copied;
-    TS_RUNINFO run_info;
-    ULONG run_info_buffer_copied;
-    LONG next_acp;
+    wchar_t buffer[1024] = {};
+    ULONG text_buffer_copied = 0;
+    TS_RUNINFO run_info = {};
+    ULONG run_info_buffer_copied = 0;
+    LONG next_acp = 0;
     EXPECT_EQ(error_code,
               text_store_->GetText(acp_start, acp_end, buffer, 1024,
                                    &text_buffer_copied,
                                    &run_info, 1, &run_info_buffer_copied,
                                    &next_acp));
   }
 
   void InsertTextAtSelectionTest(const wchar_t* buffer, ULONG buffer_size,
                                  LONG expected_start, LONG expected_end,
                                  LONG expected_change_start,
                                  LONG expected_change_old_end,
                                  LONG expected_change_new_end) {
-    LONG start, end;
-    TS_TEXTCHANGE change;
+    LONG start = 0;
+    LONG end = 0;
+    TS_TEXTCHANGE change = {};
     EXPECT_EQ(S_OK,
               text_store_->InsertTextAtSelection(0, buffer, buffer_size,
                                                  &start, &end, &change));
     EXPECT_EQ(expected_start, start);
     EXPECT_EQ(expected_end, end);
     EXPECT_EQ(expected_change_start, change.acpStart);
     EXPECT_EQ(expected_change_old_end, change.acpOldEnd);
     EXPECT_EQ(expected_change_new_end, change.acpNewEnd);
   }
 
   void InsertTextAtSelectionQueryOnlyTest(const wchar_t* buffer,
                                           ULONG buffer_size,
                                           LONG expected_start,
                                           LONG expected_end) {
-    LONG start, end;
+    LONG start = 0;
+    LONG end = 0;
     EXPECT_EQ(S_OK,
               text_store_->InsertTextAtSelection(TS_IAS_QUERYONLY, buffer,
                                                  buffer_size, &start, &end,
                                                  NULL));
     EXPECT_EQ(expected_start, start);
     EXPECT_EQ(expected_end, end);
   }
 
   void GetTextExtTest(TsViewCookie view_cookie, LONG acp_start, LONG acp_end,
                       LONG expected_left, LONG expected_top,
                       LONG expected_right, LONG expected_bottom) {
-    RECT rect;
-    BOOL clipped;
+    RECT rect = {};
+    BOOL clipped = FALSE;
     EXPECT_EQ(S_OK, text_store_->GetTextExt(view_cookie, acp_start, acp_end,
                                             &rect, &clipped));
     EXPECT_EQ(expected_left, rect.left);
     EXPECT_EQ(expected_top, rect.top);
     EXPECT_EQ(expected_right, rect.right);
     EXPECT_EQ(expected_bottom, rect.bottom);
     EXPECT_EQ(FALSE, clipped);
   }
 
   void GetTextExtNoLayoutTest(TsViewCookie view_cookie, LONG acp_start,
                               LONG acp_end) {
-    RECT rect;
-    BOOL clipped;
+    RECT rect = {};
+    BOOL clipped = FALSE;
     EXPECT_EQ(TS_E_NOLAYOUT,
               text_store_->GetTextExt(view_cookie, acp_start, acp_end,
                                       &rect, &clipped));
   }
 
-  TSFTextStore* text_store_;
+  scoped_refptr<TSFTextStore> text_store_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TSFTextStoreTestCallback);
 };
 
+namespace {
+
+const HRESULT kInvalidResult = 0x12345678;
+
 TEST_F(TSFTextStoreTest, GetStatusTest) {
-  TS_STATUS status;
+  TS_STATUS status = {};
   EXPECT_EQ(S_OK, text_store_->GetStatus(&status));
   EXPECT_EQ(0, status.dwDynamicFlags);
   EXPECT_EQ(TS_SS_TRANSITORY | TS_SS_NOHIDDENTEXT, status.dwStaticFlags);
 }
 
-
 class SyncRequestLockTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit SyncRequestLockTestCallback(TSFTextStore* text_store)
-      : TSFTextStoreTestCallback(text_store) {
-  }
+      : TSFTextStoreTestCallback(text_store) {}
 
   HRESULT LockGranted1(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
     return S_OK;
   }
 
   HRESULT LockGranted2(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
     return S_OK;
   }
 
   HRESULT LockGranted3(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ | TS_LF_SYNC, &result));
     EXPECT_EQ(TS_E_SYNCHRONOUS, result);
     return S_OK;
   }
 
   HRESULT LockGranted4(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK,
               text_store_->RequestLock(TS_LF_READWRITE | TS_LF_SYNC, &result));
     EXPECT_EQ(TS_E_SYNCHRONOUS, result);
     return S_OK;
   }
 
   HRESULT LockGranted5(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ | TS_LF_SYNC, &result));
     EXPECT_EQ(TS_E_SYNCHRONOUS, result);
     return S_OK;
   }
 
   HRESULT LockGranted6(DWORD flags) {
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK,
               text_store_->RequestLock(TS_LF_READWRITE | TS_LF_SYNC, &result));
     EXPECT_EQ(TS_E_SYNCHRONOUS, result);
     return S_OK;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SyncRequestLockTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, SynchronousRequestLockTest) {
   SyncRequestLockTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted1))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted2))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted3))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted4))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted5))
       .WillOnce(Invoke(&callback, &SyncRequestLockTestCallback::LockGranted6));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK,
             text_store_->RequestLock(TS_LF_READWRITE | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
 
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
 
+  result = kInvalidResult;
   EXPECT_EQ(S_OK,
             text_store_->RequestLock(TS_LF_READWRITE | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK,
             text_store_->RequestLock(TS_LF_READWRITE | TS_LF_SYNC, &result));
   EXPECT_EQ(S_OK, result);
 }
 
 class AsyncRequestLockTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit AsyncRequestLockTestCallback(TSFTextStore* text_store)
       : TSFTextStoreTestCallback(text_store),
-        state_(0) {
-  }
+        state_(0) {}
 
   HRESULT LockGranted1(DWORD flags) {
     EXPECT_EQ(0, state_);
     state_ = 1;
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
     EXPECT_EQ(TS_S_ASYNC, result);
     EXPECT_EQ(1, state_);
     state_ = 2;
     return S_OK;
   }
 
   HRESULT LockGranted2(DWORD flags) {
     EXPECT_EQ(2, state_);
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
     EXPECT_EQ(TS_S_ASYNC, result);
     EXPECT_EQ(2, state_);
     state_ = 3;
     return S_OK;
   }
 
   HRESULT LockGranted3(DWORD flags) {
     EXPECT_EQ(3, state_);
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
     EXPECT_EQ(TS_S_ASYNC, result);
     EXPECT_EQ(3, state_);
     state_ = 4;
     return S_OK;
   }
 
   HRESULT LockGranted4(DWORD flags) {
     EXPECT_EQ(4, state_);
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
     EXPECT_EQ(TS_S_ASYNC, result);
     EXPECT_EQ(4, state_);
     state_ = 5;
     return S_OK;
   }
 
   HRESULT LockGranted5(DWORD flags) {
     EXPECT_EQ(5, state_);
     EXPECT_TRUE(HasReadLock());
     EXPECT_FALSE(HasReadWriteLock());
     state_ = 6;
     return S_OK;
   }
 
  private:
   int state_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsyncRequestLockTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, AsynchronousRequestLockTest) {
   AsyncRequestLockTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback, &AsyncRequestLockTestCallback::LockGranted1))
       .WillOnce(Invoke(&callback, &AsyncRequestLockTestCallback::LockGranted2))
       .WillOnce(Invoke(&callback, &AsyncRequestLockTestCallback::LockGranted3))
       .WillOnce(Invoke(&callback, &AsyncRequestLockTestCallback::LockGranted4))
       .WillOnce(Invoke(&callback, &AsyncRequestLockTestCallback::LockGranted5));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
   EXPECT_EQ(S_OK, result);
 }
 
 class RequestLockTextChangeTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit RequestLockTextChangeTestCallback(TSFTextStore* text_store)
       : TSFTextStoreTestCallback(text_store),
-        state_(0) {
-  }
+        state_(0) {}
 
   HRESULT LockGranted1(DWORD flags) {
     EXPECT_EQ(0, state_);
     state_ = 1;
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
 
     *edit_flag() = true;
     SetInternalState(L"012345", 6, 6, 6);
     composition_undelines()->clear();
@@ skipping 12 matching lines @@
     EXPECT_EQ(3, state_);
     EXPECT_EQ(L"", composition.text);
     EXPECT_EQ(0, composition.selection.start());
     EXPECT_EQ(0, composition.selection.end());
     EXPECT_EQ(0, composition.underlines.size());
     state_ = 4;
   }
 
   HRESULT OnTextChange(DWORD flags, const TS_TEXTCHANGE* change) {
     EXPECT_EQ(4, state_);
-    HRESULT result;
+    HRESULT result = kInvalidResult;
     state_ = 5;
     EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
     EXPECT_EQ(S_OK, result);
     EXPECT_EQ(6, state_);
     state_ = 7;
     return S_OK;
   }
 
   HRESULT LockGranted2(DWORD flags) {
     EXPECT_EQ(5, state_);
     EXPECT_TRUE(HasReadLock());
     EXPECT_TRUE(HasReadWriteLock());
     state_ = 6;
     return S_OK;
   }
 
  private:
   int state_;
+
+  DISALLOW_COPY_AND_ASSIGN(RequestLockTextChangeTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, RequestLockOnTextChangeTest) {
   RequestLockTextChangeTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback,
                        &RequestLockTextChangeTestCallback::LockGranted1))
       .WillOnce(Invoke(&callback,
                        &RequestLockTextChangeTestCallback::LockGranted2));
 
   EXPECT_CALL(*sink_, OnSelectionChange())
       .WillOnce(Return(S_OK));
   EXPECT_CALL(*sink_, OnLayoutChange(_, _))
       .WillOnce(Return(S_OK));
   EXPECT_CALL(*sink_, OnTextChange(_, _))
       .WillOnce(Invoke(&callback,
                        &RequestLockTextChangeTestCallback::OnTextChange));
   EXPECT_CALL(text_input_client_, InsertText(_))
       .WillOnce(Invoke(&callback,
                        &RequestLockTextChangeTestCallback::InsertText));
   EXPECT_CALL(text_input_client_, SetCompositionText(_))
       .WillOnce(Invoke(&callback,
                        &RequestLockTextChangeTestCallback::SetCompositionText));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
   EXPECT_EQ(S_OK, result);
 }
 
 class SelectionTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit SelectionTestCallback(TSFTextStore* text_store)
-      : TSFTextStoreTestCallback(text_store) {
-  }
+      : TSFTextStoreTestCallback(text_store) {}
 
   HRESULT ReadLockGranted(DWORD flags) {
     SetInternalState(L"", 0, 0, 0);
 
     GetSelectionTest(0, 0);
     SetSelectionTest(0, 0, TF_E_NOLOCK);
 
     SetInternalState(L"012345", 0, 0, 3);
 
     GetSelectionTest(0, 3);
@@ skipping 59 matching lines @@
   }
 };
 
 TEST_F(TSFTextStoreTest, SetGetSelectionTest) {
   SelectionTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback, &SelectionTestCallback::ReadLockGranted))
       .WillOnce(Invoke(&callback,
                        &SelectionTestCallback::ReadWriteLockGranted));
 
-  TS_SELECTION_ACP selection_buffer;
-  ULONG fetched_count;
+  TS_SELECTION_ACP selection_buffer = {};
+  ULONG fetched_count = 0;
   EXPECT_EQ(TS_E_NOLOCK,
             text_store_->GetSelection(0, 1, &selection_buffer,
                                       &fetched_count));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
 }
 
-
 class SetGetTextTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit SetGetTextTestCallback(TSFTextStore* text_store)
-      : TSFTextStoreTestCallback(text_store) {
-  }
+      : TSFTextStoreTestCallback(text_store) {}
 
   HRESULT ReadLockGranted(DWORD flags) {
     SetTextTest(0, 0, L"", TF_E_NOLOCK);
 
     GetTextTest(0, -1, L"", 0);
     GetTextTest(0, 0, L"", 0);
     GetTextErrorTest(0, 1, TF_E_INVALIDPOS);
 
     SetInternalState(L"0123456", 3, 3, 3);
 
@@ skipping 152 matching lines @@
     GetTextTest(0, -1, L"012345abc", 9);
     GetSelectionTest(6, 9);
 
     SetInternalState(L"0123456", 3, 3, 3);
     SetTextTest(7, 7, L"abc", S_OK);
     GetTextTest(0, -1, L"0123456abc", 10);
     GetSelectionTest(7, 10);
 
     return S_OK;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SetGetTextTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, SetGetTextTest) {
   SetGetTextTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback, &SetGetTextTestCallback::ReadLockGranted))
       .WillOnce(Invoke(&callback,
                        &SetGetTextTestCallback::ReadWriteLockGranted));
 
-  wchar_t buffer[1024];
-  ULONG text_buffer_copied;
-  TS_RUNINFO run_info;
-  ULONG run_info_buffer_copied;
-  LONG next_acp;
+  wchar_t buffer[1024] = {};
+  ULONG text_buffer_copied = 0;
+  TS_RUNINFO run_info = {};
+  ULONG run_info_buffer_copied = 0;
+  LONG next_acp = 0;
   EXPECT_EQ(TF_E_NOLOCK,
             text_store_->GetText(0, -1, buffer, 1024, &text_buffer_copied,
                                  &run_info, 1, &run_info_buffer_copied,
                                  &next_acp));
-  TS_TEXTCHANGE change;
+  TS_TEXTCHANGE change = {};
   EXPECT_EQ(TF_E_NOLOCK, text_store_->SetText(0, 0, 0, L"abc", 3, &change));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
 }
 
 class InsertTextAtSelectionTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit InsertTextAtSelectionTestCallback(TSFTextStore* text_store)
-      : TSFTextStoreTestCallback(text_store) {
-  }
+      : TSFTextStoreTestCallback(text_store) {}
 
   HRESULT ReadLockGranted(DWORD flags) {
     const wchar_t kBuffer[] = L"0123456789";
 
     SetInternalState(L"abcedfg", 0, 0, 0);
     InsertTextAtSelectionQueryOnlyTest(kBuffer, 10, 0, 0);
     GetSelectionTest(0, 0);
     InsertTextAtSelectionQueryOnlyTest(kBuffer, 0, 0, 0);
 
     SetInternalState(L"abcedfg", 0, 2, 5);
     InsertTextAtSelectionQueryOnlyTest(kBuffer, 10, 2, 5);
     GetSelectionTest(2, 5);
     InsertTextAtSelectionQueryOnlyTest(kBuffer, 0, 2, 5);
 
-    LONG start, end;
-    TS_TEXTCHANGE change;
+    LONG start = 0;
+    LONG end = 0;
+    TS_TEXTCHANGE change = {};
     EXPECT_EQ(TS_E_NOLOCK,
               text_store_->InsertTextAtSelection(0, kBuffer, 10,
                                                  &start, &end, &change));
     return S_OK;
   }
 
   HRESULT ReadWriteLockGranted(DWORD flags) {
     SetInternalState(L"abcedfg", 0, 0, 0);
 
     const wchar_t kBuffer[] = L"0123456789";
@@ skipping 21 matching lines @@
     GetSelectionTest(3, 13);
     GetTextTest(0, -1, L"abc0123456789", 13);
 
     SetInternalState(L"abcedfg", 0, 7, 7);
     InsertTextAtSelectionTest(kBuffer, 10, 7, 17, 7, 7, 17);
     GetSelectionTest(7, 17);
     GetTextTest(0, -1, L"abcedfg0123456789", 17);
 
     return S_OK;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InsertTextAtSelectionTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, InsertTextAtSelectionTest) {
   InsertTextAtSelectionTestCallback callback(text_store_);
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback,
                        &InsertTextAtSelectionTestCallback::ReadLockGranted))
       .WillOnce(
           Invoke(&callback,
                  &InsertTextAtSelectionTestCallback::ReadWriteLockGranted));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
+  EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
+  EXPECT_EQ(S_OK, result);
 }
 
 class ScenarioTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit ScenarioTestCallback(TSFTextStore* text_store)
-      : TSFTextStoreTestCallback(text_store) {
-  }
+      : TSFTextStoreTestCallback(text_store) {}
 
   HRESULT LockGranted1(DWORD flags) {
     SetSelectionTest(0, 0, S_OK);
 
     SetTextTest(0, 0, L"abc", S_OK);
     SetTextTest(1, 2, L"xyz", S_OK);
 
     GetTextTest(0, -1, L"axyzc", 5);
 
     composition_undelines()->clear();
@@ skipping 74 matching lines @@
   void InsertText3(const string16& text) {
     EXPECT_EQ(L"ZCPc", text);
   }
 
   void SetCompositionText3(const ui::CompositionText& composition) {
     EXPECT_EQ(L"", composition.text);
     EXPECT_EQ(0, composition.selection.start());
     EXPECT_EQ(0, composition.selection.end());
     EXPECT_EQ(0, composition.underlines.size());
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScenarioTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, ScenarioTest) {
   ScenarioTestCallback callback(text_store_);
   EXPECT_CALL(text_input_client_, SetCompositionText(_))
       .WillOnce(Invoke(&callback, &ScenarioTestCallback::SetCompositionText1))
       .WillOnce(Invoke(&callback, &ScenarioTestCallback::SetCompositionText2))
       .WillOnce(Invoke(&callback, &ScenarioTestCallback::SetCompositionText3));
 
   EXPECT_CALL(text_input_client_, InsertText(_))
@@ skipping 10 matching lines @@
       .WillOnce(Return(S_OK));
 
   // OnLayoutChange will be called once after LockGranted3().
   EXPECT_CALL(*sink_, OnLayoutChange(_, _))
       .WillOnce(Return(S_OK));
 
   // OnTextChange will be called once after LockGranted3().
   EXPECT_CALL(*sink_, OnTextChange(_, _))
       .WillOnce(Return(S_OK));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
+  EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
+  EXPECT_EQ(S_OK, result);
+  result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READWRITE, &result));
+  EXPECT_EQ(S_OK, result);
 }
 
 class GetTextExtTestCallback : public TSFTextStoreTestCallback {
  public:
   explicit GetTextExtTestCallback(TSFTextStore* text_store)
       : TSFTextStoreTestCallback(text_store),
-        layout_prepared_character_num_(0) {
-  }
+        layout_prepared_character_num_(0) {}
 
   HRESULT LockGranted(DWORD flags) {
     SetInternalState(L"0123456789012", 0, 0, 0);
     layout_prepared_character_num_ = 13;
 
-    TsViewCookie view_cookie;
+    TsViewCookie view_cookie = 0;
     EXPECT_EQ(S_OK, text_store_->GetActiveView(&view_cookie));
     GetTextExtTest(view_cookie, 0, 0, 11, 12, 11, 20);
     GetTextExtTest(view_cookie, 0, 1, 11, 12, 20, 20);
     GetTextExtTest(view_cookie, 0, 2, 11, 12, 30, 20);
     GetTextExtTest(view_cookie, 9, 9, 100, 12, 100, 20);
     GetTextExtTest(view_cookie, 9, 10, 101, 12, 110, 20);
     GetTextExtTest(view_cookie, 10, 10, 110, 12, 110, 20);
     GetTextExtTest(view_cookie, 11, 11, 20, 112, 20, 120);
     GetTextExtTest(view_cookie, 11, 12, 21, 112, 30, 120);
     GetTextExtTest(view_cookie, 9, 12, 101, 12, 30, 120);
@@ skipping 34 matching lines @@
     rect->set_height(8);
     return true;
   }
 
   gfx::Rect GetCaretBounds() {
     return gfx::Rect(1, 2, 3, 4);
   }
 
  private:
   uint32 layout_prepared_character_num_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetTextExtTestCallback);
 };
 
 TEST_F(TSFTextStoreTest, GetTextExtTest) {
   GetTextExtTestCallback callback(text_store_);
   EXPECT_CALL(text_input_client_, GetCaretBounds())
       .WillRepeatedly(Invoke(&callback,
                              &GetTextExtTestCallback::GetCaretBounds));
 
   EXPECT_CALL(text_input_client_, GetCompositionCharacterBounds(_, _))
       .WillRepeatedly(
           Invoke(&callback,
                  &GetTextExtTestCallback::GetCompositionCharacterBounds));
 
   EXPECT_CALL(*sink_, OnLockGranted(_))
       .WillOnce(Invoke(&callback, &GetTextExtTestCallback::LockGranted));
 
-  HRESULT result;
+  HRESULT result = kInvalidResult;
   EXPECT_EQ(S_OK, text_store_->RequestLock(TS_LF_READ, &result));
+  EXPECT_EQ(S_OK, result);
 }
 
+}  // namespace
 }  // namespace ui