Update Assistant response processing logic for v2.

In response processing v1, UI elements are immediately added to the
response and are processed in unison.

In response processing v2, UI elements are pended while they each are
processed individually. Only then are they added to the response as
being ready for rendering, being careful to maintain the correct
order of insertion.

Bug: b:2063264
Change-Id: Ia487b0f7b99850314a6c83493e9f72af1b8b7b83
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2065410Reviewed-by: Xiaohui Chen <xiaohuic@chromium.org>
Commit-Queue: David Black <dmblack@google.com>
Cr-Commit-Position: refs/heads/master@{#744115}

ash/assistant/model/BUILD.gn

@@ -46,6 +46,7 @@ component("model") {
   deps = [
     "//ash/assistant/ui:constants",
     "//ash/public/cpp",
+    "//chromeos/services/assistant/public:feature_flags",
     "//chromeos/services/assistant/public/mojom",
     "//services/content/public/cpp",
     "//ui/gfx/geometry",

ash/assistant/model/assistant_response.cc

@@ -10,10 +10,25 @@
 #include "ash/assistant/model/ui/assistant_ui_element.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
+#include "chromeos/services/assistant/public/features.h"
 #include "chromeos/services/assistant/public/mojom/assistant.mojom.h"
 
 namespace ash {
 
+// AssistantResponse::PendingUiElement -----------------------------------------
+
+struct AssistantResponse::PendingUiElement {
+ public:
+  PendingUiElement() = default;
+  ~PendingUiElement() = default;
+
+  PendingUiElement(const PendingUiElement&) = delete;
+  PendingUiElement& operator=(const PendingUiElement&) = delete;
+
+  std::unique_ptr<AssistantUiElement> ui_element;
+  bool is_processing = false;
+};
+
 // AssistantResponse::Processor ------------------------------------------------
 
 class AssistantResponse::Processor {
@@ -105,8 +120,44 @@ void AssistantResponse::RemoveObserver(AssistantResponseObserver* observer) {
 
 void AssistantResponse::AddUiElement(
     std::unique_ptr<AssistantUiElement> ui_element) {
-  ui_elements_.push_back(std::move(ui_element));
-  NotifyUiElementAdded(ui_elements_.back().get());
+  // In processing v1, UI elements are immediately added to the response.
+  if (!chromeos::assistant::features::IsResponseProcessingV2Enabled()) {
+    ui_elements_.push_back(std::move(ui_element));
+    NotifyUiElementAdded(ui_elements_.back().get());
+    return;
+  }
+
+  // In processing v2, UI elements are first cached in a pending state...
+  auto pending_ui_element = std::make_unique<PendingUiElement>();
+  pending_ui_element->ui_element = std::move(ui_element);
+  pending_ui_element->is_processing = true;
+  pending_ui_elements_.push_back(std::move(pending_ui_element));
+
+  // ...while we perform any pre-processing necessary prior to rendering.
+  pending_ui_elements_.back()->ui_element->Process(base::BindOnce(
+      [](const base::WeakPtr<AssistantResponse>& self,
+         PendingUiElement* pending_ui_element) {
+        if (!self)
+          return;
+
+        // Indicate that |pending_ui_element| has finished processing.
+        pending_ui_element->is_processing = false;
+
+        // Add any UI elements that are ready for rendering to the response.
+        // Note that this may or may not include the |pending_ui_element| which
+        // just finished processing as we are required to add renderable UI
+        // elements to the response in the same order that they were initially
+        // pended to avoid inadvertently shuffling the response.
+        while (!self->pending_ui_elements_.empty() &&
+               !self->pending_ui_elements_.front()->is_processing) {
+          self->ui_elements_.push_back(
+              std::move(self->pending_ui_elements_.front()->ui_element));
+          self->pending_ui_elements_.pop_front();
+          self->NotifyUiElementAdded(self->ui_elements_.back().get());
+        }
+      },
+      weak_factory_.GetWeakPtr(),
+      base::Unretained(pending_ui_elements_.back().get())));
 }
 
 const std::vector<std::unique_ptr<AssistantUiElement>>&

ash/assistant/model/assistant_response.h

@@ -5,6 +5,7 @@
 #ifndef ASH_ASSISTANT_MODEL_ASSISTANT_RESPONSE_H_
 #define ASH_ASSISTANT_MODEL_ASSISTANT_RESPONSE_H_
 
+#include <deque>
 #include <map>
 #include <memory>
 #include <vector>
@@ -83,11 +84,13 @@ class COMPONENT_EXPORT(ASSISTANT_MODEL) AssistantResponse
   void NotifyUiElementAdded(const AssistantUiElement* ui_element);
   void NotifySuggestionsAdded(const std::vector<AssistantSuggestion*>&);
 
+  struct PendingUiElement;
   class Processor;
 
   friend class base::RefCounted<AssistantResponse>;
   ~AssistantResponse();
 
+  std::deque<std::unique_ptr<PendingUiElement>> pending_ui_elements_;
   std::vector<AssistantSuggestionPtr> suggestions_;
   ProcessingState processing_state_ = ProcessingState::kUnprocessed;
   bool has_tts_ = false;
@@ -102,6 +105,8 @@ class COMPONENT_EXPORT(ASSISTANT_MODEL) AssistantResponse
 
   base::ObserverList<AssistantResponseObserver> observers_;
 
+  base::WeakPtrFactory<AssistantResponse> weak_factory_{this};
+
   DISALLOW_COPY_AND_ASSIGN(AssistantResponse);
 };