chrome: Use base::MessageLoop. (Part 3)

chrome/browser/history/typed_url_syncable_service.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 "chrome/browser/history/typed_url_syncable_service.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
@@ skipping 46 matching lines @@
 
     previous_visit_time = visit->visit_time.ToInternalValue();
   }
   return true;
 }
 
 TypedUrlSyncableService::TypedUrlSyncableService(
     HistoryBackend* history_backend)
     : history_backend_(history_backend),
       processing_syncer_changes_(false),
-      expected_loop_(MessageLoop::current()) {
+      expected_loop_(base::MessageLoop::current()) {
   DCHECK(history_backend_);
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 }
 
 TypedUrlSyncableService::~TypedUrlSyncableService() {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 }
 
 syncer::SyncMergeResult TypedUrlSyncableService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
   DCHECK_EQ(type, syncer::TYPED_URLS);
 
   syncer::SyncMergeResult merge_result(type);
   sync_processor_ = sync_processor.Pass();
   sync_error_handler_ = error_handler.Pass();
 
   // TODO(mgist): Add implementation
 
   return merge_result;
 }
 
 void TypedUrlSyncableService::StopSyncing(syncer::ModelType type) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   DCHECK_EQ(type, syncer::TYPED_URLS);
 
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList TypedUrlSyncableService::GetAllSyncData(
     syncer::ModelType type) const {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   syncer::SyncDataList list;
 
   // TODO(mgist): Add implementation
 
   return list;
 }
 
 syncer::SyncError TypedUrlSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 
   // TODO(mgist): Add implementation
 
   return syncer::SyncError(FROM_HERE,
                            "Typed url syncable service is not implemented.",
                            syncer::TYPED_URLS);
 }
 
 void TypedUrlSyncableService::OnUrlsModified(URLRows* changed_urls) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   DCHECK(changed_urls);
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us, ignore.
   if (!sync_processor_.get())
     return;  // Sync processor not yet initialized, don't sync.
 
   // Create SyncChangeList.
   syncer::SyncChangeList changes;
 
   for (URLRows::iterator url = changed_urls->begin();
        url != changed_urls->end(); ++url) {
     // Only care if the modified URL is typed.
     if (url->typed_count() > 0) {
       // If there were any errors updating the sync node, just ignore them and
       // continue on to process the next URL.
       CreateOrUpdateSyncNode(*url, &changes);
     }
   }
 
   // Send SyncChangeList to server if there are any changes.
   if (changes.size() > 0)
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void TypedUrlSyncableService::OnUrlVisited(content::PageTransition transition,
                                            URLRow* row) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
   DCHECK(row);
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us, ignore.
   if (!sync_processor_.get())
     return;  // Sync processor not yet initialized, don't sync.
   if (!ShouldSyncVisit(transition, row))
     return;
 
   // Create SyncChangeList.
   syncer::SyncChangeList changes;
 
   CreateOrUpdateSyncNode(*row, &changes);
 
   // Send SyncChangeList to server if there are any changes.
   if (changes.size() > 0)
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void TypedUrlSyncableService::OnUrlsDeleted(bool all_history,
                                             bool archived,
                                             URLRows* rows) {
-  DCHECK(expected_loop_ == MessageLoop::current());
+  DCHECK(expected_loop_ == base::MessageLoop::current());
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us, ignore.
   if (!sync_processor_.get())
     return;  // Sync processor not yet initialized, don't sync.
 
   // Ignore archivals (we don't want to sync them as deletions, to avoid
   // extra traffic up to the server, and also to make sure that a client with
   // a bad clock setting won't go on an archival rampage and delete all
   // history from every client). The server will gracefully age out the sync DB
@@ skipping 246 matching lines @@
 
   // Sometimes, the last_visit field in the URL doesn't match the timestamp of
   // the last visit in our visit array (they come from different tables, so
   // crashes/bugs can cause them to mismatch), so just set it here.
   url->set_last_visit(visits->back().visit_time);
   DCHECK(CheckVisitOrdering(*visits));
   return true;
 }
 
 }  // namespace history