components/enhanced_bookmarks/metadata_accessor.cc

   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() || it->second.empty())
  86     return SetRemoteIdOnBookmark(bookmark_model, node);
  87
  88   return it->second;
  89 }
  90
  91 void SetDescriptionForBookmark(BookmarkModel* bookmark_model,
  92                                const BookmarkNode* node,
  93                                const std::string& description) {
  94   bookmark_model->SetNodeMetaInfo(node, kNoteKey, description);
  95 }
  96
  97 std::string DescriptionFromBookmark(const BookmarkNode* node) {
  98   const BookmarkNode::MetaInfoMap* map = node->GetMetaInfoMap();
  99   if (!map)
 100     return "";
 101
 102   // First, look for a custom note set by the user.
 103   BookmarkNode::MetaInfoMap::const_iterator it = map->find(kNoteKey);
 104   if (it != map->end() && !it->second.empty())
 105     return it->second;
 106
 107   // If none are present, return the snippet.
 108   return SnippetFromBookmark(node);
 109 }
 110
 111 bool SetOriginalImageForBookmark(BookmarkModel* bookmark_model,
 112                                  const BookmarkNode* node,
 113                                  const GURL& url,
 114                                  int width,
 115                                  int height) {
 116   DCHECK(url.is_valid());
 117
 118   std::string decoded(DataForMetaInfoField(node, kImageDataKey));
 119   ImageData data;
 120
 121   // Try to populate the imageData with the existing data.
 122   if (decoded != "") {
 123     // If the parsing fails, something is wrong. Immediately fail.
 124     bool result = data.ParseFromString(decoded);
 125     if (!result)
 126       return false;
 127   }
 128
 129   scoped_ptr<ImageData_ImageInfo> info(new ImageData_ImageInfo);
 130   info->set_url(url.spec());
 131   info->set_width(width);
 132   info->set_height(height);
 133   data.set_allocated_original_info(info.release());
 134
 135   std::string output;
 136   bool result = data.SerializePartialToString(&output);
 137   if (!result)
 138     return false;
 139
 140   std::string encoded;
 141   base::Base64Encode(output, &encoded);
 142   bookmark_model->SetNodeMetaInfo(node, kImageDataKey, encoded);
 143   // Ensure that the bookmark has a stars.id, to trigger the server processing.
 144   RemoteIdFromBookmark(bookmark_model, node);
 145   return true;
 146 }
 147
 148 bool OriginalImageFromBookmark(const BookmarkNode* node,
 149                                GURL* url,
 150                                int* width,
 151                                int* height) {
 152   std::string decoded(DataForMetaInfoField(node, kImageDataKey));
 153   if (decoded == "")
 154     return false;
 155
 156   ImageData data;
 157   bool result = data.ParseFromString(decoded);
 158   if (!result)
 159     return false;
 160
 161   if (!data.has_original_info())
 162     return false;
 163
 164   return PopulateImageData(data.original_info(), url, width, height);
 165 }
 166
 167 bool ThumbnailImageFromBookmark(const BookmarkNode* node,
 168                                 GURL* url,
 169                                 int* width,
 170                                 int* height) {
 171   std::string decoded(DataForMetaInfoField(node, kImageDataKey));
 172   if (decoded == "")
 173     return false;
 174
 175   ImageData data;
 176   bool result = data.ParseFromString(decoded);
 177   if (!result)
 178     return false;
 179
 180   if (!data.has_thumbnail_info())
 181     return false;
 182
 183   return PopulateImageData(data.thumbnail_info(), url, width, height);
 184 }
 185
 186 std::string SnippetFromBookmark(const BookmarkNode* node) {
 187   std::string decoded(DataForMetaInfoField(node, kPageDataKey));
 188   if (decoded == "")
 189     return decoded;
 190
 191   PageData data;
 192   bool result = data.ParseFromString(decoded);
 193   if (!result)
 194     return "";
 195
 196   return data.snippet();
 197 }
 198
 199 bool SetAllImagesForBookmark(BookmarkModel* bookmark_model,
 200                              const BookmarkNode* node,
 201                              const GURL& image_url,
 202                              int image_width,
 203                              int image_height,
 204                              const GURL& thumbnail_url,
 205                              int thumbnail_width,
 206                              int thumbnail_height) {
 207   DCHECK(image_url.is_valid() || image_url.is_empty());
 208   DCHECK(thumbnail_url.is_valid() || thumbnail_url.is_empty());
 209   std::string decoded(DataForMetaInfoField(node, kImageDataKey));
 210   ImageData data;
 211
 212   // Try to populate the imageData with the existing data.
 213   if (decoded != "") {
 214     // If the parsing fails, something is wrong. Immediately fail.
 215     bool result = data.ParseFromString(decoded);
 216     if (!result)
 217       return false;
 218   }
 219
 220   if (image_url.is_empty()) {
 221     data.release_original_info();
 222   } else {
 223     // Regardless of whether an image info exists, we make a new one.
 224     // Intentially make a raw pointer.
 225     ImageData_ImageInfo* info = new ImageData_ImageInfo;
 226     info->set_url(image_url.spec());
 227     info->set_width(image_width);
 228     info->set_height(image_height);
 229     // This method consumes the raw pointer.
 230     data.set_allocated_original_info(info);
 231   }
 232
 233   if (thumbnail_url.is_empty()) {
 234     data.release_thumbnail_info();
 235   } else {
 236     // Regardless of whether an image info exists, we make a new one.
 237     // Intentially make a raw pointer.
 238     ImageData_ImageInfo* info = new ImageData_ImageInfo;
 239     info->set_url(thumbnail_url.spec());
 240     info->set_width(thumbnail_width);
 241     info->set_height(thumbnail_height);
 242     // This method consumes the raw pointer.
 243     data.set_allocated_thumbnail_info(info);
 244   }
 245   std::string output;
 246   bool result = data.SerializePartialToString(&output);
 247   if (!result)
 248     return false;
 249
 250   std::string encoded;
 251   base::Base64Encode(output, &encoded);
 252   bookmark_model->SetNodeMetaInfo(node, kImageDataKey, encoded);
 253   return true;
 254 }
 255
 256 }  // namespace enhanced_bookmarks