Add incremental updates for multipage distillation.

components/dom_distiller/core/distiller.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_DISTILLER_H_
 #define COMPONENTS_DOM_DISTILLER_CORE_DISTILLER_H_
 
+#include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "components/dom_distiller/core/article_distillation_update.h"
 #include "components/dom_distiller/core/distiller_url_fetcher.h"
 #include "components/dom_distiller/core/page_distiller.h"
 #include "components/dom_distiller/core/proto/distilled_article.pb.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 namespace dom_distiller {
 
 class DistillerImpl;
 
 class Distiller {
  public:
   typedef base::Callback<void(scoped_ptr<DistilledArticleProto>)>
-      DistillerCallback;
+      DistillationFinishedCallback;
+  typedef base::Callback<void(const ArticleDistillationUpdate&)>
+      DistillationUpdateCallback;
+
   virtual ~Distiller() {}
 
-  // Distills a page, and asynchrounously returns the article HTML to the
-  // supplied callback.
+  // Distills a page, and asynchronously returns the article HTML to the
+  // supplied |finished_cb| callback. |update_cb| is invoked whenever article
+  // under distillation is updated with more data.
+  // E.g. when distilling a 2 page article, |update_cb| may be invoked each time
+  // a distilled page is added and |finished_cb| will be invoked once
+  // distillation is completed.
   virtual void DistillPage(const GURL& url,
-                           const DistillerCallback& callback) = 0;
+                           const DistillationFinishedCallback& finished_cb,
+                           const DistillationUpdateCallback& update_cb) = 0;
 };
 
 class DistillerFactory {
  public:
   virtual scoped_ptr<Distiller> CreateDistiller() = 0;
   virtual ~DistillerFactory() {}
 };
 
 // Factory for creating a Distiller.
 class DistillerFactoryImpl : public DistillerFactory {
@@ skipping 15 matching lines @@
   DistillerImpl(
       const DistillerPageFactory& distiller_page_factory,
       const DistillerURLFetcherFactory& distiller_url_fetcher_factory);
   virtual ~DistillerImpl();
 
   // Creates an execution context. This must be called once before any calls are
   // made to distill the page.
   virtual void Init();
 
   virtual void DistillPage(const GURL& url,
-                           const DistillerCallback& callback) OVERRIDE;
+                           const DistillationFinishedCallback& finished_cb,
+                           const DistillationUpdateCallback& update_cb)
+      OVERRIDE;
 
   void SetMaxNumPagesInArticle(size_t max_num_pages);
 
  private:
   // In case of multiple pages, the Distiller maintains state of multiple pages
   // as page numbers relative to the page number where distillation started.
   // E.g. if distillation starts at page 2 for a 3 page article. The relative
   // page numbers assigned to pages will be [-1,0,1].
 
   // Class representing the state of a page under distillation.
   struct DistilledPageData {
     DistilledPageData();
     virtual ~DistilledPageData();
     // Relative page number of the page.
     int page_num;
     std::string title;
     ScopedVector<DistillerURLFetcher> image_fetchers_;
-    scoped_ptr<DistilledPageProto> proto;
+    scoped_refptr<base::RefCountedData<DistilledPageProto> >
+        distilled_page_proto;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DistilledPageData);
   };
 
   void OnFetchImageDone(int page_num,
                         DistillerURLFetcher* url_fetcher,
                         const std::string& id,
                         const std::string& response);
 
@@ skipping 17 matching lines @@
   // |page_num| is either under distillation or has already completed
   // distillation.
   bool IsPageNumberInUse(int page_num) const;
 
   bool AreAllPagesFinished() const;
 
   // Total number of pages in the article that the distiller knows of, this
   // includes pages that are pending distillation.
   size_t TotalPageCount() const;
 
-  // Runs |distillation_cb_| if all distillation callbacks and image fetches are
+  // Runs |finished_cb_| if all distillation callbacks and image fetches are
   // complete.
   void RunDistillerCallbackIfDone();
 
   // Checks if page |distilled_page_data| has finished distillation, including
   // all image fetches.
   void AddPageIfDone(int page_num);
 
   DistilledPageData* GetPageAtIndex(size_t index) const;
 
+  // Create an ArticleDistillationUpdate for the current distillation
+  // state.
+  const ArticleDistillationUpdate CreateDistillationUpdate() const;
+
   const DistillerURLFetcherFactory& distiller_url_fetcher_factory_;
   scoped_ptr<PageDistiller> page_distiller_;
-  DistillerCallback distillation_cb_;
+  DistillationFinishedCallback finished_cb_;
+  DistillationUpdateCallback update_cb_;
 
   // Set of pages that are under distillation or have finished distillation.
   // |started_pages_index_| and |finished_pages_index_| maintains the mapping
   // from page number to the indices in |pages_|.
   ScopedVector<DistilledPageData> pages_;
 
   // Maps page numbers of finished pages to the indices in |pages_|.
   std::map<int, size_t> finished_pages_index_;
 
   // Maps page numbers of pages under distillation to the indices in |pages_|.
@@ skipping 11 matching lines @@
   base::hash_set<std::string> seen_urls_;
 
   size_t max_pages_in_article_;
 
   DISALLOW_COPY_AND_ASSIGN(DistillerImpl);
 };
 
 }  // namespace dom_distiller
 
 #endif  // COMPONENTS_DOM_DISTILLER_CORE_DISTILLER_H_