[Sync] Implement processing of history delete directives

chrome/browser/history/history.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
 // -----------                       --------------
 // HistoryService <----------------> HistoryBackend
 //                                   -> HistoryDatabase
 //                                      -> SQLite connection to History
 //                                   -> ArchivedDatabase
 //                                      -> SQLite connection to Archived History
 //                                   -> TextDatabaseManager
 //                                      -> SQLite connection to one month's data
 //                                      -> SQLite connection to one month's data
 //                                      ...
 //                                   -> ThumbnailDatabase
 //                                      -> SQLite connection to Thumbnails
 //                                         (and favicons)
 
 #include "chrome/browser/history/history.h"
 
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
@@ skipping 20 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory.h"
+#include "sync/protocol/history_delete_directive_specifics.pb.h"
+#include "sync/protocol/proto_value_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using base::Time;
 using history::HistoryBackend;
 
 namespace {
 
 static const char* kHistoryThreadName = "Chrome_HistoryThread";
 
@@ skipping 813 matching lines @@
     return false;
 
   return true;
 }
 
 base::WeakPtr<HistoryService> HistoryService::AsWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+void HistoryService::ProcessDeleteDirectiveForTest(
+    const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ProcessDeleteDirective(delete_directive);
+}
+
 syncer::SyncMergeResult HistoryService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(type, syncer::HISTORY_DELETE_DIRECTIVES);
   for (syncer::SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end(); ++it) {
     DCHECK_EQ(it->GetDataType(), syncer::HISTORY_DELETE_DIRECTIVES);
@@ skipping 203 matching lines @@
   visit_database_observers_.RemoveObserver(observer);
 }
 
 void HistoryService::NotifyVisitDBObserversOnAddVisit(
     const history::BriefVisitInfo& info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::VisitDatabaseObserver, visit_database_observers_,
                     OnAddVisit(info));
 }
 
+namespace {
+
+std::string DeleteDirectiveToString(
+    const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
+  scoped_ptr<base::DictionaryValue> value(
+      syncer::HistoryDeleteDirectiveSpecificsToValue(delete_directive));
+  std::string str;
+  base::JSONWriter::Write(value.get(), &str);
+  return str;
+}
+
+}  // namespace
+
 void HistoryService::ProcessDeleteDirective(
     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // TODO(akalin): Actually process the delete directive.
+
+  VLOG(1) << "Processing delete directive: "

[Nicolas Zea, 2012/11/29 22:29:43]

dvlog? (here and below)

[akalin, 2012/11/29 23:44:58]

Done.  Also fixed existing cases above.

+          << DeleteDirectiveToString(delete_directive);
+
+  base::Closure done_callback =
+      base::Bind(&HistoryService::OnDeleteDirectiveProcessed,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 delete_directive);
+
+  // Execute |done_callback| on return unless we pass it to something
+  // else.
+  base::ScopedClosureRunner scoped_done_callback(done_callback);
+
+  // Exactly one directive must be filled in.  If not, ignore.
+  if (delete_directive.has_global_id_directive() ==
+      delete_directive.has_time_range_directive()) {
+    return;
+  }
+
+  base::Closure backend_task;
+
+  if (delete_directive.has_global_id_directive()) {
+    const sync_pb::GlobalIdDirective& global_id_directive =
+        delete_directive.global_id_directive();
+    std::vector<base::Time> times;
+    for (int i = 0; i < global_id_directive.global_id_size(); ++i) {
+      int64 global_id = global_id_directive.global_id(i);
+      // The global id is just an internal time value.
+      base::Time time = base::Time::FromInternalValue(global_id);
+      times.push_back(time);
+    }
+
+    if (!times.empty()) {
+      backend_task =
+          base::Bind(&HistoryBackend::ExpireHistoryForTimes,
+                     history_backend_, times);
+    }
+  } else if (delete_directive.has_time_range_directive()) {
+    const sync_pb::TimeRangeDirective& time_range_directive =
+        delete_directive.time_range_directive();
+    // {start,end}_time_usec must both be filled in.  If not, ignore.
+    if (!time_range_directive.has_start_time_usec() ||
+        !time_range_directive.has_end_time_usec()) {
+      return;
+    }
+
+    // The directive is for the closed interval [start_time_usec,
+    // end_time_usec], but ExpireHistoryBetween() expects the
+    // half-open interval [begin_time, end_time), so add 1 to
+    // end_time_usec before converting.
+    base::Time begin_time =
+        base::Time::UnixEpoch() +
+        base::TimeDelta::FromMicroseconds(
+            time_range_directive.start_time_usec());
+    base::Time end_time =
+        base::Time::UnixEpoch() +
+        base::TimeDelta::FromMicroseconds(
+            time_range_directive.end_time_usec() + 1);
+
+    backend_task =
+        base::Bind(&HistoryBackend::ExpireHistoryBetween,
+                   history_backend_, std::set<GURL>(),
+                   begin_time, end_time);
+  }
+
+  if (!backend_task.is_null()) {
+    LoadBackendIfNecessary();
+    DCHECK(thread_);
+    if (thread_->message_loop_proxy()->PostTaskAndReply(
+            FROM_HERE,
+            backend_task,
+            done_callback)) {
+      ignore_result(scoped_done_callback.Release());
+    }
+  }
+}
+
+void HistoryService::OnDeleteDirectiveProcessed(
+    const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
+  VLOG(1) << "Processed delete directive: "
+          << DeleteDirectiveToString(delete_directive);
   // TODO(akalin): Keep track of which delete directives we've already
   // processed.
-  NOTREACHED();
 }