1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/history/android/android_history_provider_service.h" 6 7 #include "base/strings/utf_string_conversions.h" 8 #include "base/task/cancelable_task_tracker.h" 9 #include "base/time/time.h" 10 #include "chrome/browser/bookmarks/bookmark_model_factory.h" 11 #include "chrome/common/chrome_constants.h" 12 #include "chrome/test/base/testing_browser_process.h" 13 #include "chrome/test/base/testing_profile.h" 14 #include "chrome/test/base/testing_profile_manager.h" 15 #include "components/bookmarks/test/bookmark_test_helpers.h" 16 #include "components/history/core/android/android_history_types.h" 17 #include "content/public/browser/browser_thread.h" 18 #include "content/public/test/test_browser_thread.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 21 namespace { 22 23 using base::Bind; 24 using base::Time; 25 using content::BrowserThread; 26 using history::AndroidStatement; 27 using history::HistoryAndBookmarkRow; 28 using history::SearchRow; 29 30 // The test cases in this file don't intent to test the detail features of 31 // Android content provider which have been covered by 32 // android_provider_backend_unittest.cc, instead, they verify the code path to 33 // AndroidProviderBackend working fine. 34 35 class AndroidHistoryProviderServiceTest : public testing::Test { 36 public: 37 AndroidHistoryProviderServiceTest() 38 : profile_manager_( 39 TestingBrowserProcess::GetGlobal()), 40 ui_thread_(BrowserThread::UI, &message_loop_), 41 file_thread_(BrowserThread::FILE, &message_loop_) { 42 } 43 virtual ~AndroidHistoryProviderServiceTest() { 44 } 45 46 protected: 47 virtual void SetUp() OVERRIDE { 48 // Setup the testing profile, so the bookmark_model_sql_handler could 49 // get the bookmark model from it. 50 ASSERT_TRUE(profile_manager_.SetUp()); 51 // It seems that the name has to be chrome::kInitialProfile, so it 52 // could be found by ProfileManager::GetLastUsedProfile(). 53 testing_profile_ = profile_manager_.CreateTestingProfile( 54 chrome::kInitialProfile); 55 56 testing_profile_->CreateBookmarkModel(true); 57 test::WaitForBookmarkModelToLoad( 58 BookmarkModelFactory::GetForProfile(testing_profile_)); 59 ASSERT_TRUE(testing_profile_->CreateHistoryService(true, false)); 60 service_.reset(new AndroidHistoryProviderService(testing_profile_)); 61 } 62 63 virtual void TearDown() OVERRIDE { 64 testing_profile_->DestroyHistoryService(); 65 profile_manager_.DeleteTestingProfile(chrome::kInitialProfile); 66 testing_profile_=NULL; 67 } 68 69 protected: 70 TestingProfileManager profile_manager_; 71 base::MessageLoop message_loop_; 72 content::TestBrowserThread ui_thread_; 73 content::TestBrowserThread file_thread_; 74 scoped_ptr<AndroidHistoryProviderService> service_; 75 base::CancelableTaskTracker cancelable_tracker_; 76 TestingProfile* testing_profile_; 77 78 private: 79 DISALLOW_COPY_AND_ASSIGN(AndroidHistoryProviderServiceTest); 80 }; 81 82 class CallbackHelper : public base::RefCountedThreadSafe<CallbackHelper> { 83 public: 84 CallbackHelper() 85 : success_(false), 86 statement_(NULL), 87 cursor_position_(0), 88 count_(0) { 89 } 90 91 bool success() const { 92 return success_; 93 } 94 95 AndroidStatement* statement() const { 96 return statement_; 97 } 98 99 int cursor_position() const { 100 return cursor_position_; 101 } 102 103 int count() const { 104 return count_; 105 } 106 107 void OnInserted(int64 id) { 108 success_ = id != 0; 109 base::MessageLoop::current()->Quit(); 110 } 111 112 void OnQueryResult(AndroidStatement* statement) { 113 success_ = statement != NULL; 114 statement_ = statement; 115 base::MessageLoop::current()->Quit(); 116 } 117 118 void OnUpdated(int count) { 119 success_ = count != 0; 120 count_ = count; 121 base::MessageLoop::current()->Quit(); 122 } 123 124 void OnDeleted(int count) { 125 success_ = count != 0; 126 count_ = count; 127 base::MessageLoop::current()->Quit(); 128 } 129 130 void OnStatementMoved(int cursor_position) { 131 cursor_position_ = cursor_position; 132 base::MessageLoop::current()->Quit(); 133 } 134 135 private: 136 friend class base::RefCountedThreadSafe<CallbackHelper>; 137 ~CallbackHelper() { 138 } 139 140 bool success_; 141 AndroidStatement* statement_; 142 int cursor_position_; 143 int count_; 144 145 DISALLOW_COPY_AND_ASSIGN(CallbackHelper); 146 }; 147 148 TEST_F(AndroidHistoryProviderServiceTest, TestHistoryAndBookmark) { 149 HistoryAndBookmarkRow row; 150 row.set_raw_url("http://www.google.com"); 151 row.set_url(GURL("http://www.google.com")); 152 153 scoped_refptr<CallbackHelper> callback(new CallbackHelper()); 154 155 // Insert a row and verify it succeeded. 156 service_->InsertHistoryAndBookmark( 157 row, 158 Bind(&CallbackHelper::OnInserted, callback.get()), 159 &cancelable_tracker_); 160 161 base::MessageLoop::current()->Run(); 162 EXPECT_TRUE(callback->success()); 163 164 std::vector<HistoryAndBookmarkRow::ColumnID> projections; 165 projections.push_back(HistoryAndBookmarkRow::ID); 166 167 // Query the inserted row. 168 service_->QueryHistoryAndBookmarks( 169 projections, 170 std::string(), 171 std::vector<base::string16>(), 172 std::string(), 173 Bind(&CallbackHelper::OnQueryResult, callback.get()), 174 &cancelable_tracker_); 175 base::MessageLoop::current()->Run(); 176 ASSERT_TRUE(callback->success()); 177 178 // Move the cursor to the begining and verify whether we could get 179 // the same result. 180 AndroidStatement* statement = callback->statement(); 181 service_->MoveStatement( 182 statement, 183 0, 184 -1, 185 Bind(&CallbackHelper::OnStatementMoved, callback.get()), 186 &cancelable_tracker_); 187 base::MessageLoop::current()->Run(); 188 EXPECT_EQ(-1, callback->cursor_position()); 189 EXPECT_TRUE(callback->statement()->statement()->Step()); 190 EXPECT_FALSE(callback->statement()->statement()->Step()); 191 service_->CloseStatement(statement); 192 193 // Update the row. 194 HistoryAndBookmarkRow update_row; 195 update_row.set_visit_count(3); 196 service_->UpdateHistoryAndBookmarks( 197 update_row, 198 std::string(), 199 std::vector<base::string16>(), 200 Bind(&CallbackHelper::OnUpdated, callback.get()), 201 &cancelable_tracker_); 202 base::MessageLoop::current()->Run(); 203 EXPECT_TRUE(callback->success()); 204 EXPECT_EQ(1, callback->count()); 205 206 // Delete the row. 207 service_->DeleteHistoryAndBookmarks( 208 std::string(), 209 std::vector<base::string16>(), 210 Bind(&CallbackHelper::OnDeleted, callback.get()), 211 &cancelable_tracker_); 212 base::MessageLoop::current()->Run(); 213 EXPECT_TRUE(callback->success()); 214 EXPECT_EQ(1, callback->count()); 215 } 216 217 TEST_F(AndroidHistoryProviderServiceTest, TestSearchTerm) { 218 SearchRow search_row; 219 search_row.set_search_term(base::UTF8ToUTF16("google")); 220 search_row.set_url(GURL("http://google.com")); 221 search_row.set_keyword_id(1); 222 search_row.set_search_time(Time::Now()); 223 224 scoped_refptr<CallbackHelper> callback(new CallbackHelper()); 225 226 // Insert a row and verify it succeeded. 227 service_->InsertSearchTerm(search_row, 228 Bind(&CallbackHelper::OnInserted, callback.get()), 229 &cancelable_tracker_); 230 231 base::MessageLoop::current()->Run(); 232 EXPECT_TRUE(callback->success()); 233 234 std::vector<SearchRow::ColumnID> projections; 235 projections.push_back(SearchRow::ID); 236 237 // Query the inserted row. 238 service_->QuerySearchTerms( 239 projections, 240 std::string(), 241 std::vector<base::string16>(), 242 std::string(), 243 Bind(&CallbackHelper::OnQueryResult, callback.get()), 244 &cancelable_tracker_); 245 base::MessageLoop::current()->Run(); 246 ASSERT_TRUE(callback->success()); 247 248 // Move the cursor to the begining and verify whether we could get 249 // the same result. 250 AndroidStatement* statement = callback->statement(); 251 service_->MoveStatement( 252 statement, 253 0, 254 -1, 255 Bind(&CallbackHelper::OnStatementMoved, callback.get()), 256 &cancelable_tracker_); 257 base::MessageLoop::current()->Run(); 258 EXPECT_EQ(-1, callback->cursor_position()); 259 EXPECT_TRUE(callback->statement()->statement()->Step()); 260 EXPECT_FALSE(callback->statement()->statement()->Step()); 261 service_->CloseStatement(statement); 262 263 // Update the row. 264 SearchRow update_row; 265 update_row.set_search_time(Time::Now()); 266 service_->UpdateSearchTerms(update_row, 267 std::string(), 268 std::vector<base::string16>(), 269 Bind(&CallbackHelper::OnUpdated, callback.get()), 270 &cancelable_tracker_); 271 base::MessageLoop::current()->Run(); 272 EXPECT_TRUE(callback->success()); 273 EXPECT_EQ(1, callback->count()); 274 275 // Delete the row. 276 service_->DeleteSearchTerms(std::string(), 277 std::vector<base::string16>(), 278 Bind(&CallbackHelper::OnDeleted, callback.get()), 279 &cancelable_tracker_); 280 base::MessageLoop::current()->Run(); 281 EXPECT_TRUE(callback->success()); 282 EXPECT_EQ(1, callback->count()); 283 } 284 285 } // namespace 286
