Add a DistilledContentStore (and an in-memory impl)

components/dom_distiller/core/task_tracker.h

 // 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.
 
 #ifndef COMPONENTS_DOM_DISTILLER_CORE_TASK_TRACKER_H_
 #define COMPONENTS_DOM_DISTILLER_CORE_TASK_TRACKER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "components/dom_distiller/core/article_distillation_update.h"
 #include "components/dom_distiller/core/article_entry.h"
 #include "components/dom_distiller/core/distiller.h"
 #include "components/dom_distiller/core/proto/distilled_page.pb.h"
 
 class GURL;
 
 namespace dom_distiller {
 
 class DistilledArticleProto;
+class DistilledContentStore;
 
 // A handle to a request to view a DOM distiller entry or URL. The request will
 // be cancelled when the handle is destroyed.
 class ViewerHandle {
  public:
   typedef base::Callback<void()> CancelCallback;
   explicit ViewerHandle(CancelCallback callback);
   ~ViewerHandle();
 
  private:
@@ skipping 34 matching lines @@
 //
 // After creating a TaskTracker, a consumer of distilled content should be added
 // and at least one of the sources should be started.
 class TaskTracker {
  public:
   typedef base::Callback<void(TaskTracker*)> CancelCallback;
   typedef base::Callback<
       void(const ArticleEntry&, const DistilledArticleProto*, bool)>
       SaveCallback;
 
-  TaskTracker(const ArticleEntry& entry, CancelCallback callback);
+  TaskTracker(const ArticleEntry& entry,
+              CancelCallback callback,
+              DistilledContentStore* content_store);
   ~TaskTracker();
 
   // |factory| will not be stored after this call.
   void StartDistiller(DistillerFactory* factory);
   void StartBlobFetcher();
 
   void AddSaveCallback(const SaveCallback& callback);
 
   void CancelSaveCallbacks();
 
   // The ViewerHandle should be destroyed before the ViewRequestDelegate.
   scoped_ptr<ViewerHandle> AddViewer(ViewRequestDelegate* delegate);
 
   const std::string& GetEntryId() const;
   bool HasEntryId(const std::string& entry_id) const;
   bool HasUrl(const GURL& url) const;
 
  private:
   void OnDistillerFinished(scoped_ptr<DistilledArticleProto> distilled_article);
+  void OnBlobFetched(bool success,
+                     scoped_ptr<DistilledArticleProto> distilled_article);
 
   void OnDistilledArticleReady(
       scoped_ptr<DistilledArticleProto> distilled_article);
   void OnArticleDistillationUpdated(
       const ArticleDistillationUpdate& article_update);
   // Posts a task to run DoSaveCallbacks with |distillation_succeeded|.
   void ScheduleSaveCallbacks(bool distillation_succeeded);
 
   // Runs all callbacks passing |distillation_succeeded| and clears them. Should
   // be called through ScheduleSaveCallbacks.
   void DoSaveCallbacks(bool distillation_succeeded);
 
+  void AddDistilledContentToStore();
+
   void RemoveViewer(ViewRequestDelegate* delegate);
   void NotifyViewer(ViewRequestDelegate* delegate);
 
   void MaybeCancel();
 
   CancelCallback cancel_callback_;
+
+  DistilledContentStore* content_store_;
+
   std::vector<SaveCallback> save_callbacks_;
-
-  scoped_ptr<Distiller> distiller_;
-
   // A ViewRequestDelegate will be added to this list when a view request is
   // made and removed when the corresponding ViewerHandle is destroyed.
   std::vector<ViewRequestDelegate*> viewers_;
 
+  scoped_ptr<Distiller> distiller_;
+
   ArticleEntry entry_;
   scoped_ptr<DistilledArticleProto> distilled_article_;
 
   bool content_ready_;
 
   bool destruction_allowed_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<TaskTracker> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskTracker);
 };
 
 }  // namespace dom_distiller
 
 #endif  // COMPONENTS_DOM_DISTILLER_CORE_TASK_TRACKER_H_