Add support for multipage distillation.

components/dom_distiller/core/task_tracker.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/task_tracker.h"
 
 #include "base/message_loop/message_loop.h"
+#include "components/dom_distiller/core/proto/distilled_article.pb.h"
+#include "components/dom_distiller/core/proto/distilled_page.pb.h"
 
 namespace dom_distiller {
 
 ViewerHandle::ViewerHandle(CancelCallback callback)
     : cancel_callback_(callback) {}
 
 ViewerHandle::~ViewerHandle() {
   if (!cancel_callback_.is_null()) {
     cancel_callback_.Run();
   }
 }
 
 TaskTracker::TaskTracker(const ArticleEntry& entry, CancelCallback callback)
     : cancel_callback_(callback),
       entry_(entry),
-      distilled_page_(),
+      distilled_article_(),
+      distillation_complete_(false),
       weak_ptr_factory_(this) {}
 
 TaskTracker::~TaskTracker() { DCHECK(viewers_.empty()); }
 
 void TaskTracker::StartDistiller(DistillerFactory* factory) {
   if (distiller_) {
     return;
   }
   if (entry_.pages_size() == 0) {
     return;
@@ skipping 10 matching lines @@
 
 void TaskTracker::StartBlobFetcher() {
   // TODO(cjhopman): There needs to be some local storage for the distilled
   // blob. When that happens, this should start some task to fetch the blob for
   // |entry_| and asynchronously notify |this| when it is done.
 }
 
 void TaskTracker::AddSaveCallback(const SaveCallback& callback) {
   DCHECK(!callback.is_null());
   save_callbacks_.push_back(callback);
-  if (distilled_page_) {
+  if (distillation_complete_) {
     // Distillation for this task has already completed, and so it can be
     // immediately saved.
     ScheduleSaveCallbacks(true);
   }
 }
 
 scoped_ptr<ViewerHandle> TaskTracker::AddViewer(ViewRequestDelegate* delegate) {
   viewers_.push_back(delegate);
-  if (distilled_page_) {
+  if (distillation_complete_) {
     // Distillation for this task has already completed, and so the delegate can
     // be immediately told of the result.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&TaskTracker::NotifyViewer,
                    weak_ptr_factory_.GetWeakPtr(),
                    delegate));
   }
   return scoped_ptr<ViewerHandle>(new ViewerHandle(base::Bind(
       &TaskTracker::RemoveViewer, weak_ptr_factory_.GetWeakPtr(), delegate)));
@@ skipping 39 matching lines @@
 void TaskTracker::ScheduleSaveCallbacks(bool distillation_succeeded) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&TaskTracker::DoSaveCallbacks,
                  weak_ptr_factory_.GetWeakPtr(),
                  distillation_succeeded));
 }
 
 void TaskTracker::DoSaveCallbacks(bool distillation_succeeded) {
   if (!save_callbacks_.empty()) {
-    DistilledPageProto* distilled_proto =
-        distillation_succeeded ? distilled_page_.get() : NULL;
-
     for (size_t i = 0; i < save_callbacks_.size(); ++i) {
       DCHECK(!save_callbacks_[i].is_null());
-      save_callbacks_[i].Run(entry_, distilled_proto, distillation_succeeded);
+      save_callbacks_[i].Run(
+          entry_, distilled_article_.get(), distillation_succeeded);
     }
 
     save_callbacks_.clear();
     MaybeCancel();
   }
 }
 
 void TaskTracker::NotifyViewer(ViewRequestDelegate* delegate) {
-  DCHECK(distilled_page_);
-  delegate->OnArticleReady(distilled_page_.get());
+  DCHECK(distillation_complete_);
+  delegate->OnArticleReady(distilled_article_.get());
 }
 
-void TaskTracker::OnDistilledDataReady(scoped_ptr<DistilledPageProto> proto) {
-  distilled_page_ = proto.Pass();
-  DCHECK(distilled_page_);
+void TaskTracker::OnDistilledDataReady(
+    scoped_ptr<DistilledArticleProto> distilled_article) {
+  distilled_article_ = distilled_article.Pass();
+  bool distillation_successful = false;
+  if (distilled_article_->pages_size() > 0) {
+    distillation_successful = true;
+    entry_.set_title(distilled_article_->title());
+    // Reset the pages.
+    entry_.clear_pages();
+    for (int i = 0; i < distilled_article_->pages_size(); ++i) {
+      sync_pb::ArticlePage* page = entry_.add_pages();
+      page->set_url(distilled_article_->pages(i).url());
+    }
+  }
 
-  entry_.set_title(distilled_page_->title());
+  distillation_complete_ = true;
+
   for (size_t i = 0; i < viewers_.size(); ++i) {
     NotifyViewer(viewers_[i]);
   }
 
   // Already inside a callback run SaveCallbacks directly.
-  DoSaveCallbacks(true);
+  DoSaveCallbacks(distillation_successful);
 }
 
 }  // namespace dom_distiller