Dont set NEEDS_OFFLINE_PROCESSING flag.

components/enhanced_bookmarks/enhanced_bookmark_model.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
 
 #include <iomanip>
 #include <sstream>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/enhanced_bookmarks/enhanced_bookmark_model_observer.h"
 #include "components/enhanced_bookmarks/proto/metadata.pb.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "url/gurl.h"
 
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 
 namespace {
 const char* kBookmarkBarId = "f_bookmarks_bar";
 
-const char* kFlagsKey = "stars.flags";
 const char* kIdKey = "stars.id";
 const char* kImageDataKey = "stars.imageData";
 const char* kNoteKey = "stars.note";
 const char* kOldIdKey = "stars.oldId";
 const char* kPageDataKey = "stars.pageData";
 const char* kVersionKey = "stars.version";
 
 const char* kBookmarkPrefix = "ebc_";
 
-enum Flags {
-  // When set the server will attempt to fill in image and snippet information.
-  NEEDS_OFFLINE_PROCESSING = 0x1,
-};
-
 // Helper method for working with bookmark metainfo.
 std::string DataForMetaInfoField(const BookmarkNode* node,
                                  const std::string& field) {
   std::string value;
   if (!node->GetMetaInfo(field, &value))
     return std::string();
 
   std::string decoded;
   if (!base::Base64Decode(value, &decoded))
     return std::string();
@@ skipping 252 matching lines @@
 }
 
 void EnhancedBookmarkModel::BookmarkNodeAdded(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
   const BookmarkNode* node = parent->GetChild(index);
   std::string remote_id;
   if (node->GetMetaInfo(kIdKey, &remote_id)) {
     AddToIdMap(node);
     ScheduleResetDuplicateRemoteIds();
-  } else if (node->is_url()) {
-    set_needs_offline_processing_tasks_[node] =
-        make_linked_ptr(new base::CancelableClosure(
-            base::Bind(&EnhancedBookmarkModel::SetNeedsOfflineProcessing,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       base::Unretained(node))));
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE, set_needs_offline_processing_tasks_[node]->callback());
   }
   FOR_EACH_OBSERVER(
       EnhancedBookmarkModelObserver, observers_, EnhancedBookmarkAdded(node));
 }
 
 void EnhancedBookmarkModel::BookmarkNodeRemoved(
     BookmarkModel* model,
     const BookmarkNode* parent,
     int old_index,
     const BookmarkNode* node,
@@ skipping 68 matching lines @@
   }
 }
 
 void EnhancedBookmarkModel::RemoveNodeFromMaps(const BookmarkNode* node) {
   for (int i = 0; i < node->child_count(); i++) {
     RemoveNodeFromMaps(node->GetChild(i));
   }
   std::string remote_id = GetRemoteId(node);
   id_map_.erase(remote_id);
   nodes_to_reset_.erase(node);
-  set_needs_offline_processing_tasks_.erase(node);
 }
 
 void EnhancedBookmarkModel::ScheduleResetDuplicateRemoteIds() {
   if (!nodes_to_reset_.empty()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&EnhancedBookmarkModel::ResetDuplicateRemoteIds,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void EnhancedBookmarkModel::ResetDuplicateRemoteIds() {
   for (NodeToIdMap::iterator it = nodes_to_reset_.begin();
        it != nodes_to_reset_.end();
        ++it) {
     BookmarkNode::MetaInfoMap meta_info;
     meta_info[kIdKey] = "";
     meta_info[kOldIdKey] = it->second;
     SetMultipleMetaInfo(it->first, meta_info);
   }
   nodes_to_reset_.clear();
 }
 
-void EnhancedBookmarkModel::SetNeedsOfflineProcessing(
-    const BookmarkNode* node) {
-  set_needs_offline_processing_tasks_.erase(node);
-  int flags = 0;
-  std::string flags_str;
-  if (node->GetMetaInfo(kFlagsKey, &flags_str)) {
-    if (!base::StringToInt(flags_str, &flags))
-      flags = 0;
-  }
-  flags |= NEEDS_OFFLINE_PROCESSING;
-  SetMetaInfo(node, kFlagsKey, base::IntToString(flags));
-}
-
 void EnhancedBookmarkModel::SetMetaInfo(const BookmarkNode* node,
                                         const std::string& field,
                                         const std::string& value) {
   DCHECK(!bookmark_model_->is_permanent_node(node));
 
   BookmarkNode::MetaInfoMap meta_info;
   const BookmarkNode::MetaInfoMap* old_meta_info = node->GetMetaInfoMap();
   if (old_meta_info)
     meta_info.insert(old_meta_info->begin(), old_meta_info->end());
 
@@ skipping 97 matching lines @@
   if (!result)
     return false;
 
   std::string encoded;
   base::Base64Encode(output, &encoded);
   bookmark_model_->SetNodeMetaInfo(node, kImageDataKey, encoded);
   return true;
 }
 
 }  // namespace enhanced_bookmarks