src/chrome/browser/history/history_backend_android.cc

   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/history_backend.h"
   6
   7 #include "chrome/browser/history/android/android_provider_backend.h"
   8
   9 namespace history {
  10
  11 void HistoryBackend::InsertHistoryAndBookmark(
  12     scoped_refptr<InsertRequest> request,
  13     const HistoryAndBookmarkRow& row) {
  14   if (request->canceled())
  15     return;
  16
  17   AndroidURLID id = 0;
  18   if (android_provider_backend_)
  19     id = android_provider_backend_->InsertHistoryAndBookmark(row);
  20
  21   request->ForwardResult(request->handle(), id != 0, id);
  22 }
  23
  24 void HistoryBackend::QueryHistoryAndBookmarks(
  25     scoped_refptr<QueryRequest> request,
  26     const std::vector<HistoryAndBookmarkRow::ColumnID>& projections,
  27     const std::string& selection,
  28     const std::vector<string16>& selection_args,
  29     const std::string& sort_order) {
  30   if (request->canceled())
  31     return;
  32
  33   AndroidStatement* statement = NULL;
  34   if (android_provider_backend_) {
  35     statement = android_provider_backend_->QueryHistoryAndBookmarks(
  36         projections, selection, selection_args, sort_order);
  37   }
  38   request->ForwardResult(request->handle(), statement, statement);
  39 }
  40
  41 void HistoryBackend::UpdateHistoryAndBookmarks(
  42     scoped_refptr<UpdateRequest> request,
  43     const HistoryAndBookmarkRow& row,
  44     const std::string& selection,
  45     const std::vector<string16>& selection_args) {
  46   if (request->canceled())
  47     return;
  48
  49   int count = 0;
  50   bool result = false;
  51   if (android_provider_backend_) {
  52     result = android_provider_backend_->UpdateHistoryAndBookmarks(row,
  53         selection, selection_args, &count);
  54   }
  55
  56   request->ForwardResult(request->handle(), result, count);
  57 }
  58
  59 void HistoryBackend::DeleteHistoryAndBookmarks(
  60     scoped_refptr<DeleteRequest> request,
  61     const std::string& selection,
  62     const std::vector<string16>& selection_args) {
  63   if (request->canceled())
  64     return;
  65
  66   int count = 0;
  67   bool result = false;
  68   if (android_provider_backend_)
  69     result = android_provider_backend_->DeleteHistoryAndBookmarks(selection,
  70         selection_args, &count);
  71
  72   request->ForwardResult(request->handle(), result, count);
  73 }
  74
  75 void HistoryBackend::DeleteHistory(
  76     scoped_refptr<DeleteRequest> request,
  77     const std::string& selection,
  78     const std::vector<string16>& selection_args) {
  79   if (request->canceled())
  80     return;
  81
  82   int count = 0;
  83   bool result = false;
  84   if (android_provider_backend_) {
  85     result = android_provider_backend_->DeleteHistory(selection, selection_args,
  86                                                       &count);
  87   }
  88   request->ForwardResult(request->handle(), result, count);
  89 }
  90
  91 // Statement -------------------------------------------------------------------
  92
  93 void HistoryBackend::MoveStatement(
  94     scoped_refptr<MoveStatementRequest> request,
  95     history::AndroidStatement* statement,
  96     int current_pos,
  97     int destination) {
  98   DCHECK_LE(-1, current_pos);
  99   DCHECK_LE(-1, destination);
 100
 101   int cur = current_pos;
 102   if (current_pos > destination) {
 103     statement->statement()->Reset(false);
 104     cur = -1;
 105   }
 106   for (; cur < destination; ++cur) {
 107     if (!statement->statement()->Step())
 108       break;
 109   }
 110
 111   request->ForwardResult(request->handle(), cur);
 112 }
 113
 114 void HistoryBackend::CloseStatement(AndroidStatement* statement) {
 115   delete statement;
 116 }
 117
 118 // Search Term -----------------------------------------------------------------
 119
 120 void HistoryBackend::InsertSearchTerm(scoped_refptr<InsertRequest> request,
 121                                       const SearchRow& row) {
 122   if (request->canceled())
 123     return;
 124
 125   SearchTermID id = 0;
 126   if (android_provider_backend_)
 127     id = android_provider_backend_->InsertSearchTerm(row);
 128
 129   request->ForwardResult(request->handle(), id != 0, id);
 130 }
 131
 132 void HistoryBackend::UpdateSearchTerms(
 133     scoped_refptr<UpdateRequest> request,
 134     const SearchRow& row,
 135     const std::string& selection,
 136     const std::vector<string16> selection_args) {
 137   if (request->canceled())
 138     return;
 139
 140   int count = 0;
 141   bool result = false;
 142   if (android_provider_backend_) {
 143     result =  android_provider_backend_->UpdateSearchTerms(row, selection,
 144         selection_args, &count);
 145   }
 146   request->ForwardResult(request->handle(), result, count);
 147 }
 148
 149 void HistoryBackend::DeleteSearchTerms(
 150     scoped_refptr<DeleteRequest> request,
 151     const std::string& selection,
 152     const std::vector<string16> selection_args) {
 153   if (request->canceled())
 154     return;
 155
 156   int count = 0;
 157   bool result = false;
 158   if (android_provider_backend_) {
 159     result = android_provider_backend_->DeleteSearchTerms(selection,
 160         selection_args, &count);
 161   }
 162
 163   request->ForwardResult(request->handle(), result, count);
 164 }
 165
 166 void HistoryBackend::QuerySearchTerms(
 167     scoped_refptr<QueryRequest> request,
 168     const std::vector<SearchRow::ColumnID>& projections,
 169     const std::string& selection,
 170     const std::vector<string16>& selection_args,
 171     const std::string& sort_order) {
 172   if (request->canceled())
 173     return;
 174
 175   AndroidStatement* statement = NULL;
 176   if (android_provider_backend_)
 177     statement = android_provider_backend_->QuerySearchTerms(projections,
 178         selection, selection_args, sort_order);
 179
 180   request->ForwardResult(request->handle(), statement, statement);
 181 }
 182
 183 }  // namespace history