| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "components/enhanced_bookmarks/metadata_accessor.h" | |
| 6 | |
| 7 #include <iomanip> | |
| 8 | |
| 9 #include "base/base64.h" | |
| 10 #include "base/rand_util.h" | |
| 11 #include "components/bookmarks/browser/bookmark_model.h" | |
| 12 #include "components/enhanced_bookmarks/proto/metadata.pb.h" | |
| 13 #include "ui/base/models/tree_node_iterator.h" | |
| 14 | |
| 15 using namespace image::collections; | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // Helper method for working with bookmark metainfo. | |
| 20 std::string DataForMetaInfoField(const BookmarkNode* node, | |
| 21 const std::string& field) { | |
| 22 const BookmarkNode::MetaInfoMap* map = node->GetMetaInfoMap(); | |
| 23 if (!map) | |
| 24 return ""; | |
| 25 | |
| 26 BookmarkNode::MetaInfoMap::const_iterator it = map->find(field); | |
| 27 if (it == map->end()) | |
| 28 return ""; | |
| 29 | |
| 30 std::string decoded; | |
| 31 bool result = base::Base64Decode((*it).second, &decoded); | |
| 32 if (!result) | |
| 33 return ""; | |
| 34 | |
| 35 return decoded; | |
| 36 } | |
| 37 | |
| 38 // Sets a new remote id on a bookmark. | |
| 39 std::string SetRemoteIdOnBookmark(BookmarkModel* bookmark_model, | |
| 40 const BookmarkNode* node) { | |
| 41 // Generate 16 digit hex string random id. | |
| 42 std::stringstream random_id; | |
| 43 random_id << std::hex << std::setfill('0') << std::setw(16); | |
| 44 random_id << base::RandUint64() << base::RandUint64(); | |
| 45 std::string random_id_str = random_id.str(); | |
| 46 bookmark_model->SetNodeMetaInfo( | |
| 47 node, enhanced_bookmarks::kIdDataKey, random_id_str); | |
| 48 return random_id_str; | |
| 49 } | |
| 50 | |
| 51 // Helper method for working with ImageData_ImageInfo. | |
| 52 bool PopulateImageData(const ImageData_ImageInfo& info, | |
| 53 GURL* out_url, | |
| 54 int* width, | |
| 55 int* height) { | |
| 56 if (!info.has_url() || !info.has_width() || !info.has_height()) | |
| 57 return false; | |
| 58 | |
| 59 GURL url(info.url()); | |
| 60 if (!url.is_valid()) | |
| 61 return false; | |
| 62 | |
| 63 *out_url = url; | |
| 64 *width = info.width(); | |
| 65 *height = info.height(); | |
| 66 return true; | |
| 67 } | |
| 68 | |
| 69 } // namespace | |
| 70 | |
| 71 namespace enhanced_bookmarks { | |
| 72 | |
| 73 const char* kPageDataKey = "stars.pageData"; | |
| 74 const char* kImageDataKey = "stars.imageData"; | |
| 75 const char* kIdDataKey = "stars.id"; | |
| 76 const char* kNoteKey = "stars.note"; | |
| 77 | |
| 78 std::string RemoteIdFromBookmark(BookmarkModel* bookmark_model, | |
| 79 const BookmarkNode* node) { | |
| 80 const BookmarkNode::MetaInfoMap* map = node->GetMetaInfoMap(); | |
| 81 if (!map) | |
| 82 return SetRemoteIdOnBookmark(bookmark_model, node); | |
| 83 | |
| 84 BookmarkNode::MetaInfoMap::const_iterator it = map->find(kIdDataKey); | |
| 85 if (it == map->end()) | |
| 86 return SetRemoteIdOnBookmark(bookmark_model, node); | |
| 87 | |
| 88 DCHECK(it->second.length()); | |
| 89 return it->second; | |
| 90 } | |
| 91 | |
| 92 void SetDescriptionForBookmark(BookmarkModel* bookmark_model, | |
| 93 const BookmarkNode* node, | |
| 94 const std::string& description) { | |
| 95 bookmark_model->SetNodeMetaInfo(node, kNoteKey, description); | |
| 96 } | |
| 97 | |
| 98 std::string DescriptionFromBookmark(const BookmarkNode* node) { | |
| 99 const BookmarkNode::MetaInfoMap* map = node->GetMetaInfoMap(); | |
| 100 if (!map) | |
| 101 return ""; | |
| 102 | |
| 103 // First, look for a custom note set by the user. | |
| 104 BookmarkNode::MetaInfoMap::const_iterator it = map->find(kNoteKey); | |
| 105 if (it != map->end() && it->second != "") | |
| 106 return it->second; | |
| 107 | |
| 108 // If none are present, return the snippet. | |
| 109 return SnippetFromBookmark(node); | |
| 110 } | |
| 111 | |
| 112 bool SetOriginalImageForBookmark(BookmarkModel* bookmark_model, | |
| 113 const BookmarkNode* node, | |
| 114 const GURL& url, | |
| 115 int width, | |
| 116 int height) { | |
| 117 DCHECK(url.is_valid()); | |
| 118 | |
| 119 std::string decoded(DataForMetaInfoField(node, kImageDataKey)); | |
| 120 ImageData data; | |
| 121 | |
| 122 // Try to populate the imageData with the existing data. | |
| 123 if (decoded != "") { | |
| 124 // If the parsing fails, something is wrong. Immediately fail. | |
| 125 bool result = data.ParseFromString(decoded); | |
| 126 if (!result) | |
| 127 return false; | |
| 128 } | |
| 129 | |
| 130 scoped_ptr<ImageData_ImageInfo> info(new ImageData_ImageInfo); | |
| 131 info->set_url(url.spec()); | |
| 132 info->set_width(width); | |
| 133 info->set_height(height); | |
| 134 data.set_allocated_original_info(info.release()); | |
| 135 | |
| 136 std::string output; | |
| 137 bool result = data.SerializePartialToString(&output); | |
| 138 if (!result) | |
| 139 return false; | |
| 140 | |
| 141 std::string encoded; | |
| 142 base::Base64Encode(output, &encoded); | |
| 143 bookmark_model->SetNodeMetaInfo(node, kImageDataKey, encoded); | |
| 144 // Ensure that the bookmark has a stars.id, to trigger the server processing. | |
| 145 RemoteIdFromBookmark(bookmark_model, node); | |
| 146 return true; | |
| 147 } | |
| 148 | |
| 149 bool OriginalImageFromBookmark(const BookmarkNode* node, | |
| 150 GURL* url, | |
| 151 int* width, | |
| 152 int* height) { | |
| 153 std::string decoded(DataForMetaInfoField(node, kImageDataKey)); | |
| 154 if (decoded == "") | |
| 155 return false; | |
| 156 | |
| 157 ImageData data; | |
| 158 bool result = data.ParseFromString(decoded); | |
| 159 if (!result) | |
| 160 return false; | |
| 161 | |
| 162 if (!data.has_original_info()) | |
| 163 return false; | |
| 164 | |
| 165 return PopulateImageData(data.original_info(), url, width, height); | |
| 166 } | |
| 167 | |
| 168 bool ThumbnailImageFromBookmark(const BookmarkNode* node, | |
| 169 GURL* url, | |
| 170 int* width, | |
| 171 int* height) { | |
| 172 std::string decoded(DataForMetaInfoField(node, kImageDataKey)); | |
| 173 if (decoded == "") | |
| 174 return false; | |
| 175 | |
| 176 ImageData data; | |
| 177 bool result = data.ParseFromString(decoded); | |
| 178 if (!result) | |
| 179 return false; | |
| 180 | |
| 181 if (!data.has_thumbnail_info()) | |
| 182 return false; | |
| 183 | |
| 184 return PopulateImageData(data.thumbnail_info(), url, width, height); | |
| 185 } | |
| 186 | |
| 187 std::string SnippetFromBookmark(const BookmarkNode* node) { | |
| 188 std::string decoded(DataForMetaInfoField(node, kPageDataKey)); | |
| 189 if (decoded == "") | |
| 190 return decoded; | |
| 191 | |
| 192 PageData data; | |
| 193 bool result = data.ParseFromString(decoded); | |
| 194 if (!result) | |
| 195 return ""; | |
| 196 | |
| 197 return data.snippet(); | |
| 198 } | |
| 199 | |
| 200 bool SetAllImagesForBookmark(BookmarkModel* bookmark_model, | |
| 201 const BookmarkNode* node, | |
| 202 const GURL& image_url, | |
| 203 int image_width, | |
| 204 int image_height, | |
| 205 const GURL& thumbnail_url, | |
| 206 int thumbnail_width, | |
| 207 int thumbnail_height) { | |
| 208 DCHECK(image_url.is_valid() || image_url.is_empty()); | |
| 209 DCHECK(thumbnail_url.is_valid() || thumbnail_url.is_empty()); | |
| 210 std::string decoded(DataForMetaInfoField(node, kImageDataKey)); | |
| 211 ImageData data; | |
| 212 | |
| 213 // Try to populate the imageData with the existing data. | |
| 214 if (decoded != "") { | |
| 215 // If the parsing fails, something is wrong. Immediately fail. | |
| 216 bool result = data.ParseFromString(decoded); | |
| 217 if (!result) | |
| 218 return false; | |
| 219 } | |
| 220 | |
| 221 if (image_url.is_empty()) { | |
| 222 data.release_original_info(); | |
| 223 } else { | |
| 224 // Regardless of whether an image info exists, we make a new one. | |
| 225 // Intentially make a raw pointer. | |
| 226 ImageData_ImageInfo* info = new ImageData_ImageInfo; | |
| 227 info->set_url(image_url.spec()); | |
| 228 info->set_width(image_width); | |
| 229 info->set_height(image_height); | |
| 230 // This method consumes the raw pointer. | |
| 231 data.set_allocated_original_info(info); | |
| 232 } | |
| 233 | |
| 234 if (thumbnail_url.is_empty()) { | |
| 235 data.release_thumbnail_info(); | |
| 236 } else { | |
| 237 // Regardless of whether an image info exists, we make a new one. | |
| 238 // Intentially make a raw pointer. | |
| 239 ImageData_ImageInfo* info = new ImageData_ImageInfo; | |
| 240 info->set_url(thumbnail_url.spec()); | |
| 241 info->set_width(thumbnail_width); | |
| 242 info->set_height(thumbnail_height); | |
| 243 // This method consumes the raw pointer. | |
| 244 data.set_allocated_thumbnail_info(info); | |
| 245 } | |
| 246 std::string output; | |
| 247 bool result = data.SerializePartialToString(&output); | |
| 248 if (!result) | |
| 249 return false; | |
| 250 | |
| 251 std::string encoded; | |
| 252 base::Base64Encode(output, &encoded); | |
| 253 bookmark_model->SetNodeMetaInfo(node, kImageDataKey, encoded); | |
| 254 return true; | |
| 255 } | |
| 256 | |
| 257 } // namespace enhanced_bookmarks | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 476573004:
Set version field when changes are made to enhanced bookmarks. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src@master