chrome/browser/history/history_backend_android.cc - Issue 930363002: Remove adapter method on HistoryBackend delegating to AndroidProviderBackend

Side by Side Diff: chrome/browser/history/history_backend_android.cc

Issue 930363002: Remove adapter method on HistoryBackend delegating to AndroidProviderBackend (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« chrome/browser/history/android/android_history_provider_service.cc ('K') | « chrome/browser/history/history_backend.h ('k') | chrome/browser/history/history_service.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
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 AndroidURLID HistoryBackend::InsertHistoryAndBookmark(

12 const HistoryAndBookmarkRow& row) {

13 AndroidURLID id = 0;

14 if (android_provider_backend_)

15 id = android_provider_backend_->InsertHistoryAndBookmark(row);

16 return id;

17 }

18

19 AndroidStatement* HistoryBackend::QueryHistoryAndBookmarks(

20 const std::vector<HistoryAndBookmarkRow::ColumnID>& projections,

21 const std::string& selection,

22 const std::vector<base::string16>& selection_args,

23 const std::string& sort_order) {

24 AndroidStatement* statement = NULL;

25 if (android_provider_backend_) {

26 statement = android_provider_backend_->QueryHistoryAndBookmarks(

27 projections, selection, selection_args, sort_order);

28 }

29 return statement;

30 }

31

32 int HistoryBackend::UpdateHistoryAndBookmarks(

33 const HistoryAndBookmarkRow& row,

34 const std::string& selection,

35 const std::vector<base::string16>& selection_args) {

36 int count = 0;

37 if (android_provider_backend_) {

38 android_provider_backend_->UpdateHistoryAndBookmarks(

39 row, selection, selection_args, &count);

40 }

41 return count;

42 }

43

44 int HistoryBackend::DeleteHistoryAndBookmarks(

45 const std::string& selection,

46 const std::vector<base::string16>& selection_args) {

47 int count = 0;

48 if (android_provider_backend_) {

49 android_provider_backend_->DeleteHistoryAndBookmarks(

50 selection, selection_args, &count);

51 }

52 return count;

53 }

54

55 int HistoryBackend::DeleteHistory(

56 const std::string& selection,

57 const std::vector<base::string16>& selection_args) {

58 int count = 0;

59 if (android_provider_backend_) {

60 android_provider_backend_->DeleteHistory(selection, selection_args, &count);

61 }

62 return count;

63 }

64

65 // Statement -------------------------------------------------------------------

66

67 int HistoryBackend::MoveStatement(history::AndroidStatement* statement,

68 int current_pos,

69 int destination) {

70 DCHECK_LE(-1, current_pos);

71 DCHECK_LE(-1, destination);

72

73 int cur = current_pos;

74 if (current_pos > destination) {

75 statement->statement()->Reset(false);

76 cur = -1;

77 }

78 for (; cur < destination; ++cur) {

79 if (!statement->statement()->Step())

80 break;

81 }

82

83 return cur;

84 }

85

86 void HistoryBackend::CloseStatement(AndroidStatement* statement) {

87 delete statement;

88 }

89

90 // Search Term -----------------------------------------------------------------

91

92 SearchTermID HistoryBackend::InsertSearchTerm(const SearchRow& row) {

93 SearchTermID id = 0;

94 if (android_provider_backend_)

95 id = android_provider_backend_->InsertSearchTerm(row);

96 return id;

97 }

98

99 int HistoryBackend::UpdateSearchTerms(

100 const SearchRow& row,

101 const std::string& selection,

102 const std::vector<base::string16> selection_args) {

103 int count = 0;

104 if (android_provider_backend_) {

105 android_provider_backend_->UpdateSearchTerms(

106 row, selection, selection_args, &count);

107 }

108 return count;

109 }

110

111 int HistoryBackend::DeleteSearchTerms(

112 const std::string& selection,

113 const std::vector<base::string16> selection_args) {

114 int count = 0;

115 if (android_provider_backend_) {

116 android_provider_backend_->DeleteSearchTerms(

117 selection, selection_args, &count);

118 }

119 return count;

120 }

121

122 AndroidStatement* HistoryBackend::QuerySearchTerms(

123 const std::vector<SearchRow::ColumnID>& projections,

124 const std::string& selection,

125 const std::vector<base::string16>& selection_args,

126 const std::string& sort_order) {

127 AndroidStatement* statement = NULL;

128 if (android_provider_backend_) {

129 statement = android_provider_backend_->QuerySearchTerms(projections,

130 selection, selection_args, sort_order);

131 }

132 return statement;

133 }

134

135 } // namespace history

OLD	NEW