Add a DistilledContentStore (and an in-memory impl)

components/dom_distiller/core/dom_distiller_service.cc

 // Copyright 2013 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/dom_distiller/core/dom_distiller_service.h"
 
 #include "base/guid.h"
 #include "base/message_loop/message_loop.h"
+#include "components/dom_distiller/core/distilled_content_store.h"
 #include "components/dom_distiller/core/dom_distiller_store.h"
 #include "components/dom_distiller/core/proto/distilled_article.pb.h"
 #include "components/dom_distiller/core/task_tracker.h"
 #include "url/gurl.h"
 
 namespace dom_distiller {
 
 namespace {
 
 ArticleEntry CreateSkeletonEntryForUrl(const GURL& url) {
@@ skipping 12 matching lines @@
     const DistilledArticleProto* article_proto,
     bool distillation_succeeded) {
   article_cb.Run(distillation_succeeded);
 }
 
 }  // namespace
 
 DomDistillerService::DomDistillerService(
     scoped_ptr<DomDistillerStoreInterface> store,
     scoped_ptr<DistillerFactory> distiller_factory)
-    : store_(store.Pass()), distiller_factory_(distiller_factory.Pass()) {}
+    : store_(store.Pass()),
+      content_store_(new InMemoryContentStore()),
+      distiller_factory_(distiller_factory.Pass()) {}
 
 DomDistillerService::~DomDistillerService() {}
 
 syncer::SyncableService* DomDistillerService::GetSyncableService() const {
   return store_->GetSyncableService();
 }
 
 const std::string DomDistillerService::AddToList(
     const GURL& url,
     const ArticleAvailableCallback& article_cb) {
@@ skipping 19 matching lines @@
   }
 
   if (!article_cb.is_null()) {
     task_tracker->AddSaveCallback(
         base::Bind(&RunArticleAvailableCallback, article_cb));
   }
 
   if (!is_already_added) {
     task_tracker->AddSaveCallback(base::Bind(
         &DomDistillerService::AddDistilledPageToList, base::Unretained(this)));
+    task_tracker->AddSaveCallback(
+        base::Bind(&DomDistillerService::AddDistilledContentToStore,
+                   base::Unretained(this)));
     task_tracker->StartDistiller(distiller_factory_.get());
+    task_tracker->StartBlobFetcher();
   }
 
   return task_tracker->GetEntryId();
 }
 
 std::vector<ArticleEntry> DomDistillerService::GetEntries() const {
   return store_->GetEntries();
 }
 
 scoped_ptr<ArticleEntry> DomDistillerService::RemoveEntry(
@@ skipping 18 matching lines @@
 scoped_ptr<ViewerHandle> DomDistillerService::ViewEntry(
     ViewRequestDelegate* delegate,
     const std::string& entry_id) {
   ArticleEntry entry;
   if (!store_->GetEntryById(entry_id, &entry)) {
     return scoped_ptr<ViewerHandle>();
   }
 
   TaskTracker* task_tracker = GetOrCreateTaskTrackerForEntry(entry);
   scoped_ptr<ViewerHandle> viewer_handle = task_tracker->AddViewer(delegate);
+  task_tracker->AddSaveCallback(
+      base::Bind(&DomDistillerService::AddDistilledContentToStore,
+                 base::Unretained(this)));
   task_tracker->StartDistiller(distiller_factory_.get());
+  task_tracker->StartBlobFetcher();
 
   return viewer_handle.Pass();
 }
 
 scoped_ptr<ViewerHandle> DomDistillerService::ViewUrl(
     ViewRequestDelegate* delegate,
     const GURL& url) {
   if (!url.is_valid()) {
     return scoped_ptr<ViewerHandle>();
   }
 
   TaskTracker* task_tracker = GetOrCreateTaskTrackerForUrl(url);
   scoped_ptr<ViewerHandle> viewer_handle = task_tracker->AddViewer(delegate);
+  task_tracker->AddSaveCallback(
+      base::Bind(&DomDistillerService::AddDistilledContentToStore,

[shashi, 2014/03/13 00:32:45]

Feels like these 3 lines can be now refactored to a function.

+                 base::Unretained(this)));
   task_tracker->StartDistiller(distiller_factory_.get());
+  task_tracker->StartBlobFetcher();
 
   return viewer_handle.Pass();
 }
 
 TaskTracker* DomDistillerService::GetOrCreateTaskTrackerForUrl(
     const GURL& url) {
   ArticleEntry entry;
   if (store_->GetEntryByUrl(url, &entry)) {
     return GetOrCreateTaskTrackerForEntry(entry);
   }
@@ skipping 25 matching lines @@
   TaskTracker* task_tracker = GetTaskTrackerForEntry(entry);
   if (task_tracker == NULL) {
     task_tracker = CreateTaskTracker(entry);
   }
   return task_tracker;
 }
 
 TaskTracker* DomDistillerService::CreateTaskTracker(const ArticleEntry& entry) {
   TaskTracker::CancelCallback cancel_callback =
       base::Bind(&DomDistillerService::CancelTask, base::Unretained(this));
-  TaskTracker* tracker = new TaskTracker(entry, cancel_callback);
+  TaskTracker* tracker =
+      new TaskTracker(entry, cancel_callback, content_store_.get());
   tasks_.push_back(tracker);
   return tracker;
 }
 
 void DomDistillerService::CancelTask(TaskTracker* task) {
   TaskList::iterator it = std::find(tasks_.begin(), tasks_.end(), task);
   if (it != tasks_.end()) {
     tasks_.weak_erase(it);
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, task);
   }
 }
 
 void DomDistillerService::AddDistilledPageToList(
     const ArticleEntry& entry,
     const DistilledArticleProto* article_proto,
     bool distillation_succeeded) {
   DCHECK(IsEntryValid(entry));
   if (distillation_succeeded) {
     DCHECK(article_proto);
     DCHECK_GT(article_proto->pages_size(), 0);
     store_->AddEntry(entry);
     DCHECK_EQ(article_proto->pages_size(), entry.pages_size());
   }
 }
 
+void DomDistillerService::AddDistilledContentToStore(
+    const ArticleEntry& entry,
+    const DistilledArticleProto* article_proto,
+    bool distillation_succeeded) {
+  DCHECK(IsEntryValid(entry));
+  if (distillation_succeeded) {
+    DCHECK(article_proto);
+    DCHECK_GT(article_proto->pages_size(), 0);
+    content_store_->SaveContent(
+        entry, *article_proto, DistilledContentStore::SaveCallback());
+    DCHECK_EQ(article_proto->pages_size(), entry.pages_size());
+  }
+}
+
 void DomDistillerService::AddObserver(DomDistillerObserver* observer) {
   DCHECK(observer);
   store_->AddObserver(observer);
 }
 
 void DomDistillerService::RemoveObserver(DomDistillerObserver* observer) {
   DCHECK(observer);
   store_->RemoveObserver(observer);
 }
 
 }  // namespace dom_distiller