src/chrome/browser/history/delete_directive_handler.cc

   1 // Copyright (c) 2013 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/delete_directive_handler.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/rand_util.h"
   9 #include "base/time/time.h"
  10 #include "base/values.h"
  11 #include "chrome/browser/history/history_backend.h"
  12 #include "chrome/browser/history/history_db_task.h"
  13 #include "chrome/browser/history/history_service.h"
  14 #include "sync/api/sync_change.h"
  15 #include "sync/protocol/history_delete_directive_specifics.pb.h"
  16 #include "sync/protocol/proto_value_conversions.h"
  17 #include "sync/protocol/sync.pb.h"
  18
  19 namespace {
  20
  21 std::string RandASCIIString(size_t length) {
  22   std::string result;
  23   const int kMin = static_cast<int>(' ');
  24   const int kMax = static_cast<int>('~');
  25   for (size_t i = 0; i < length; ++i)
  26     result.push_back(static_cast<char>(base::RandInt(kMin, kMax)));
  27   return result;
  28 }
  29
  30 std::string DeleteDirectiveToString(
  31     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
  32   scoped_ptr<base::DictionaryValue> value(
  33       syncer::HistoryDeleteDirectiveSpecificsToValue(delete_directive));
  34   std::string str;
  35   base::JSONWriter::Write(value.get(), &str);
  36   return str;
  37 }
  38
  39 // Compare time range directives first by start time, then by end time.
  40 bool TimeRangeLessThan(const syncer::SyncData& data1,
  41                        const syncer::SyncData& data2) {
  42   const sync_pb::TimeRangeDirective& range1 =
  43       data1.GetSpecifics().history_delete_directive().time_range_directive();
  44   const sync_pb::TimeRangeDirective& range2 =
  45       data2.GetSpecifics().history_delete_directive().time_range_directive();
  46   if (range1.start_time_usec() < range2.start_time_usec())
  47     return true;
  48   if (range1.start_time_usec() > range2.start_time_usec())
  49     return false;
  50   return range1.end_time_usec() < range2.end_time_usec();
  51 }
  52
  53 // Converts a Unix timestamp in microseconds to a base::Time value.
  54 base::Time UnixUsecToTime(int64 usec) {
  55   return base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(usec);
  56 }
  57
  58 // Converts a base::Time value to a Unix timestamp in microseconds.
  59 int64 TimeToUnixUsec(base::Time time) {
  60   DCHECK(!time.is_null());
  61   return (time - base::Time::UnixEpoch()).InMicroseconds();
  62 }
  63
  64 // Converts global IDs in |global_id_directive| to times.
  65 void GetTimesFromGlobalIds(
  66     const sync_pb::GlobalIdDirective& global_id_directive,
  67     std::set<base::Time> *times) {
  68   for (int i = 0; i < global_id_directive.global_id_size(); ++i) {
  69     times->insert(
  70         base::Time::FromInternalValue(global_id_directive.global_id(i)));
  71   }
  72 }
  73
  74 #if !defined(NDEBUG)
  75 // Checks that the given delete directive is properly formed.
  76 void CheckDeleteDirectiveValid(
  77     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
  78   if (delete_directive.has_global_id_directive()) {
  79     const sync_pb::GlobalIdDirective& global_id_directive =
  80         delete_directive.global_id_directive();
  81
  82     DCHECK(!delete_directive.has_time_range_directive());
  83     DCHECK_NE(global_id_directive.global_id_size(), 0);
  84     if (global_id_directive.has_start_time_usec())
  85       DCHECK_GE(global_id_directive.start_time_usec(), 0);
  86     if (global_id_directive.has_end_time_usec()) {
  87       DCHECK_GT(global_id_directive.end_time_usec(), 0);
  88
  89       if (global_id_directive.has_start_time_usec()) {
  90         DCHECK_LE(global_id_directive.start_time_usec(),
  91                   global_id_directive.end_time_usec());
  92       }
  93     }
  94
  95   } else if (delete_directive.has_time_range_directive()) {
  96     const sync_pb::TimeRangeDirective& time_range_directive =
  97         delete_directive.time_range_directive();
  98
  99     DCHECK(!delete_directive.has_global_id_directive());
 100     DCHECK(time_range_directive.has_start_time_usec());
 101     DCHECK(time_range_directive.has_end_time_usec());
 102     DCHECK_GE(time_range_directive.start_time_usec(), 0);
 103     DCHECK_GT(time_range_directive.end_time_usec(), 0);
 104     DCHECK_GT(time_range_directive.end_time_usec(),
 105               time_range_directive.start_time_usec());
 106   } else {
 107     NOTREACHED() << "Delete directive has no time range or global ID directive";
 108   }
 109 }
 110 #endif  // !defined(NDEBUG)
 111
 112 }  // anonymous namespace
 113
 114 namespace history {
 115
 116 class DeleteDirectiveHandler::DeleteDirectiveTask : public HistoryDBTask {
 117  public:
 118   DeleteDirectiveTask(
 119       base::WeakPtr<DeleteDirectiveHandler> delete_directive_handler,
 120       const syncer::SyncDataList& delete_directive,
 121       DeleteDirectiveHandler::PostProcessingAction post_processing_action)
 122      : delete_directive_handler_(delete_directive_handler),
 123        delete_directives_(delete_directive),
 124        post_processing_action_(post_processing_action) {}
 125
 126   // Implements HistoryDBTask.
 127   virtual bool RunOnDBThread(history::HistoryBackend* backend,
 128                              history::HistoryDatabase* db) OVERRIDE;
 129   virtual void DoneRunOnMainThread() OVERRIDE;
 130
 131  private:
 132   virtual ~DeleteDirectiveTask() {}
 133
 134   // Process a list of global Id directives. Delete all visits to a URL in
 135   // time ranges of directives if the timestamp of one visit matches with one
 136   // global id.
 137   void ProcessGlobalIdDeleteDirectives(
 138       history::HistoryBackend* history_backend,
 139       const syncer::SyncDataList& global_id_directives);
 140
 141   // Process a list of time range directives, all history entries within the
 142   // time ranges are deleted. |time_range_directives| should be sorted by
 143   // |start_time_usec| and |end_time_usec| already.
 144   void ProcessTimeRangeDeleteDirectives(
 145       history::HistoryBackend* history_backend,
 146       const syncer::SyncDataList& time_range_directives);
 147
 148   base::WeakPtr<DeleteDirectiveHandler> delete_directive_handler_;
 149   syncer::SyncDataList delete_directives_;
 150   DeleteDirectiveHandler::PostProcessingAction post_processing_action_;
 151 };
 152
 153 bool DeleteDirectiveHandler::DeleteDirectiveTask::RunOnDBThread(
 154     history::HistoryBackend* backend,
 155     history::HistoryDatabase* db) {
 156   syncer::SyncDataList global_id_directives;
 157   syncer::SyncDataList time_range_directives;
 158   for (syncer::SyncDataList::const_iterator it = delete_directives_.begin();
 159        it != delete_directives_.end(); ++it) {
 160     DCHECK_EQ(it->GetDataType(), syncer::HISTORY_DELETE_DIRECTIVES);
 161     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive =
 162         it->GetSpecifics().history_delete_directive();
 163     if (delete_directive.has_global_id_directive()) {
 164       global_id_directives.push_back(*it);
 165     } else {
 166       time_range_directives.push_back(*it);
 167     }
 168   }
 169
 170   ProcessGlobalIdDeleteDirectives(backend, global_id_directives);
 171   std::sort(time_range_directives.begin(), time_range_directives.end(),
 172             TimeRangeLessThan);
 173   ProcessTimeRangeDeleteDirectives(backend, time_range_directives);
 174   return true;
 175 }
 176
 177 void DeleteDirectiveHandler::DeleteDirectiveTask::DoneRunOnMainThread() {
 178   if (delete_directive_handler_.get()) {
 179     delete_directive_handler_->FinishProcessing(post_processing_action_,
 180                                                 delete_directives_);
 181   }
 182 }
 183
 184 void
 185 DeleteDirectiveHandler::DeleteDirectiveTask::ProcessGlobalIdDeleteDirectives(
 186     history::HistoryBackend* history_backend,
 187     const syncer::SyncDataList& global_id_directives) {
 188   if (global_id_directives.empty())
 189     return;
 190
 191   // Group times represented by global IDs by time ranges of delete directives.
 192   // It's more efficient for backend to process all directives with same time
 193   // range at once.
 194   typedef std::map<std::pair<base::Time, base::Time>, std::set<base::Time> >
 195       GlobalIdTimesGroup;
 196   GlobalIdTimesGroup id_times_group;
 197   for (size_t i = 0; i < global_id_directives.size(); ++i) {
 198     DVLOG(1) << "Processing delete directive: "
 199              << DeleteDirectiveToString(
 200                     global_id_directives[i].GetSpecifics()
 201                         .history_delete_directive());
 202
 203     const sync_pb::GlobalIdDirective& id_directive =
 204         global_id_directives[i].GetSpecifics().history_delete_directive()
 205             .global_id_directive();
 206     if (id_directive.global_id_size() == 0 ||
 207         !id_directive.has_start_time_usec() ||
 208         !id_directive.has_end_time_usec()) {
 209       DLOG(ERROR) << "Invalid global id directive.";
 210       continue;
 211     }
 212     GetTimesFromGlobalIds(
 213         id_directive,
 214         &id_times_group[
 215             std::make_pair(UnixUsecToTime(id_directive.start_time_usec()),
 216                            UnixUsecToTime(id_directive.end_time_usec()))]);
 217   }
 218
 219   if (id_times_group.empty())
 220     return;
 221
 222   // Call backend to expire history of directives in each group.
 223   for (GlobalIdTimesGroup::const_iterator group_it = id_times_group.begin();
 224       group_it != id_times_group.end(); ++group_it) {
 225     // Add 1us to cover history entries visited at the end time because time
 226     // range in directive is inclusive.
 227     history_backend->ExpireHistoryForTimes(
 228         group_it->second,
 229         group_it->first.first,
 230         group_it->first.second + base::TimeDelta::FromMicroseconds(1));
 231   }
 232 }
 233
 234 void
 235 DeleteDirectiveHandler::DeleteDirectiveTask::ProcessTimeRangeDeleteDirectives(
 236     history::HistoryBackend* history_backend,
 237     const syncer::SyncDataList& time_range_directives) {
 238   if (time_range_directives.empty())
 239     return;
 240
 241   // Iterate through time range directives. Expire history in combined
 242   // time range for multiple directives whose time ranges overlap.
 243   base::Time current_start_time;
 244   base::Time current_end_time;
 245   for (size_t i = 0; i < time_range_directives.size(); ++i) {
 246     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive =
 247         time_range_directives[i].GetSpecifics().history_delete_directive();
 248     DVLOG(1) << "Processing time range directive: "
 249              << DeleteDirectiveToString(delete_directive);
 250
 251     const sync_pb::TimeRangeDirective& time_range_directive =
 252         delete_directive.time_range_directive();
 253     if (!time_range_directive.has_start_time_usec() ||
 254         !time_range_directive.has_end_time_usec() ||
 255         time_range_directive.start_time_usec() >=
 256             time_range_directive.end_time_usec()) {
 257       DLOG(ERROR) << "Invalid time range directive.";
 258       continue;
 259     }
 260
 261     base::Time directive_start_time =
 262         UnixUsecToTime(time_range_directive.start_time_usec());
 263     base::Time directive_end_time =
 264         UnixUsecToTime(time_range_directive.end_time_usec());
 265     if (directive_start_time > current_end_time) {
 266       if (!current_start_time.is_null()) {
 267         // Add 1us to cover history entries visited at the end time because
 268         // time range in directive is inclusive.
 269         history_backend->ExpireHistoryBetween(
 270             std::set<GURL>(), current_start_time,
 271             current_end_time + base::TimeDelta::FromMicroseconds(1));
 272       }
 273       current_start_time = directive_start_time;
 274     }
 275     if (directive_end_time > current_end_time)
 276       current_end_time = directive_end_time;
 277   }
 278
 279   if (!current_start_time.is_null()) {
 280     history_backend->ExpireHistoryBetween(
 281         std::set<GURL>(), current_start_time,
 282         current_end_time + base::TimeDelta::FromMicroseconds(1));
 283   }
 284 }
 285
 286 DeleteDirectiveHandler::DeleteDirectiveHandler()
 287     : weak_ptr_factory_(this) {}
 288
 289 DeleteDirectiveHandler::~DeleteDirectiveHandler() {
 290   weak_ptr_factory_.InvalidateWeakPtrs();
 291 }
 292
 293 void DeleteDirectiveHandler::Start(
 294     HistoryService* history_service,
 295     const syncer::SyncDataList& initial_sync_data,
 296     scoped_ptr<syncer::SyncChangeProcessor> sync_processor) {
 297   DCHECK(thread_checker_.CalledOnValidThread());
 298   sync_processor_ = sync_processor.Pass();
 299   if (!initial_sync_data.empty()) {
 300     // Drop processed delete directives during startup.
 301     history_service->ScheduleDBTask(
 302         scoped_ptr<history::HistoryDBTask>(
 303             new DeleteDirectiveTask(weak_ptr_factory_.GetWeakPtr(),
 304                                     initial_sync_data,
 305                                     DROP_AFTER_PROCESSING)),
 306         &internal_tracker_);
 307   }
 308 }
 309
 310 void DeleteDirectiveHandler::Stop() {
 311   DCHECK(thread_checker_.CalledOnValidThread());
 312   sync_processor_.reset();
 313 }
 314
 315 bool DeleteDirectiveHandler::CreateDeleteDirectives(
 316     const std::set<int64>& global_ids,
 317     base::Time begin_time,
 318     base::Time end_time) {
 319   base::Time now = base::Time::Now();
 320   sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
 321
 322   // Delete directives require a non-null begin time, so use 1 if it's null.
 323   int64 begin_time_usecs =
 324       begin_time.is_null() ? 0 : TimeToUnixUsec(begin_time);
 325
 326   // Determine the actual end time -- it should not be null or in the future.
 327   // TODO(dubroy): Use sane time (crbug.com/146090) here when it's available.
 328   base::Time end = (end_time.is_null() || end_time > now) ? now : end_time;
 329   // -1 because end time in delete directives is inclusive.
 330   int64 end_time_usecs = TimeToUnixUsec(end) - 1;
 331
 332   if (global_ids.empty()) {
 333     sync_pb::TimeRangeDirective* time_range_directive =
 334         delete_directive.mutable_time_range_directive();
 335     time_range_directive->set_start_time_usec(begin_time_usecs);
 336     time_range_directive->set_end_time_usec(end_time_usecs);
 337   } else {
 338     for (std::set<int64>::const_iterator it = global_ids.begin();
 339          it != global_ids.end(); ++it) {
 340       sync_pb::GlobalIdDirective* global_id_directive =
 341           delete_directive.mutable_global_id_directive();
 342       global_id_directive->add_global_id(*it);
 343       global_id_directive->set_start_time_usec(begin_time_usecs);
 344       global_id_directive->set_end_time_usec(end_time_usecs);
 345     }
 346   }
 347   syncer::SyncError error = ProcessLocalDeleteDirective(delete_directive);
 348   return !error.IsSet();
 349 }
 350
 351 syncer::SyncError DeleteDirectiveHandler::ProcessLocalDeleteDirective(
 352     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
 353   DCHECK(thread_checker_.CalledOnValidThread());
 354   if (!sync_processor_) {
 355     return syncer::SyncError(
 356         FROM_HERE,
 357         syncer::SyncError::DATATYPE_ERROR,
 358         "Cannot send local delete directive to sync",
 359         syncer::HISTORY_DELETE_DIRECTIVES);
 360   }
 361 #if !defined(NDEBUG)
 362   CheckDeleteDirectiveValid(delete_directive);
 363 #endif
 364
 365   // Generate a random sync tag since history delete directives don't
 366   // have a 'built-in' ID.  8 bytes should suffice.
 367   std::string sync_tag = RandASCIIString(8);
 368   sync_pb::EntitySpecifics entity_specifics;
 369   entity_specifics.mutable_history_delete_directive()->CopyFrom(
 370       delete_directive);
 371   syncer::SyncData sync_data =
 372       syncer::SyncData::CreateLocalData(
 373           sync_tag, sync_tag, entity_specifics);
 374   syncer::SyncChange change(
 375       FROM_HERE, syncer::SyncChange::ACTION_ADD, sync_data);
 376   syncer::SyncChangeList changes(1, change);
 377   return sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 378 }
 379
 380 syncer::SyncError DeleteDirectiveHandler::ProcessSyncChanges(
 381     HistoryService* history_service,
 382     const syncer::SyncChangeList& change_list) {
 383   DCHECK(thread_checker_.CalledOnValidThread());
 384   if (!sync_processor_) {
 385     return syncer::SyncError(
 386         FROM_HERE,
 387         syncer::SyncError::DATATYPE_ERROR,
 388         "Sync is disabled.",
 389         syncer::HISTORY_DELETE_DIRECTIVES);
 390   }
 391
 392   syncer::SyncDataList delete_directives;
 393   for (syncer::SyncChangeList::const_iterator it = change_list.begin();
 394        it != change_list.end(); ++it) {
 395     switch (it->change_type()) {
 396       case syncer::SyncChange::ACTION_ADD:
 397         delete_directives.push_back(it->sync_data());
 398         break;
 399       case syncer::SyncChange::ACTION_DELETE:
 400         // TODO(akalin): Keep track of existing delete directives.
 401         break;
 402       default:
 403         NOTREACHED();
 404         break;
 405     }
 406   }
 407
 408   if (!delete_directives.empty()) {
 409     // Don't drop real-time delete directive so that sync engine can detect
 410     // redelivered delete directives to avoid processing them again and again
 411     // in one chrome session.
 412     history_service->ScheduleDBTask(
 413         scoped_ptr<history::HistoryDBTask>(
 414             new DeleteDirectiveTask(weak_ptr_factory_.GetWeakPtr(),
 415                                     delete_directives,
 416                                     KEEP_AFTER_PROCESSING)),
 417         &internal_tracker_);
 418   }
 419   return syncer::SyncError();
 420 }
 421
 422 void DeleteDirectiveHandler::FinishProcessing(
 423     PostProcessingAction post_processing_action,
 424     const syncer::SyncDataList& delete_directives) {
 425   DCHECK(thread_checker_.CalledOnValidThread());
 426
 427   // If specified, drop processed delete directive in sync model because they
 428   // only need to be applied once.
 429   if (sync_processor_.get() &&
 430       post_processing_action == DROP_AFTER_PROCESSING) {
 431     syncer::SyncChangeList change_list;
 432     for (size_t i = 0; i < delete_directives.size(); ++i) {
 433       change_list.push_back(
 434           syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_DELETE,
 435                              delete_directives[i]));
 436     }
 437     sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
 438   }
 439 }
 440
 441 }  // namespace history