[WebView] Remove onFailure from VisualStateCallback.

content/renderer/gpu/frame_swap_message_queue.cc

 // Copyright 2014 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 "content/renderer/gpu/frame_swap_message_queue.h"
 
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "content/common/frame_messages.h"
 #include "ipc/ipc_message.h"
 
 using std::vector;
 
 namespace content {
 
 class FrameSwapMessageSubQueue {
  public:
   FrameSwapMessageSubQueue() {}
   virtual ~FrameSwapMessageSubQueue() {}
   virtual bool Empty() const = 0;
   virtual void QueueMessage(int source_frame_number,
                             scoped_ptr<IPC::Message> msg,
                             bool* is_first) = 0;
-  virtual void DrainMessages(int source_frame_number,
-                             ScopedVector<IPC::Message>* messages) = 0;
+  virtual void OnDrainMessages(ScopedVector<IPC::Message>* messages) = 0;
+  virtual void OnDidSwap(int source_frame_number,
+                         ScopedVector<IPC::Message>* messages) = 0;
+  virtual void OnDidNotSwap(int source_frame_number,
+                            cc::SwapPromise::DidNotSwapReason reason,
+                            ScopedVector<IPC::Message>* messages) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FrameSwapMessageSubQueue);
 };
 
 namespace {
 
 // Queue specific to MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE.
 class SendMessageScopeImpl : public FrameSwapMessageQueue::SendMessageScope {
  public:
@@ skipping 19 matching lines @@
 
   void QueueMessage(int source_frame_number,
                     scoped_ptr<IPC::Message> msg,
                     bool* is_first) override {
     if (is_first)
       *is_first = (queue_.count(source_frame_number) == 0);
 
     queue_[source_frame_number].push_back(msg.release());
   }
 
-  void DrainMessages(int source_frame_number,
-                     ScopedVector<IPC::Message>* messages) override {
+  void DeliverSwapInfo(const std::set<int32>& routing_ids,
+                       int source_frame_number,
+                       bool swap_success,
+                       ScopedVector<IPC::Message>* messages) {
+    for (auto& routing_id : routing_ids) {
+      messages->push_back(new FrameHostMsg_VisualStateSwapInfo(
+          routing_id, source_frame_number, swap_success));
+    }
+  }
+
+  std::set<int32> GetRoutingIDs(int source_frame_number) {
+    std::set<int32> routing_ids;
     VisualStateQueueMap::iterator end = queue_.upper_bound(source_frame_number);
     for (VisualStateQueueMap::iterator i = queue_.begin(); i != end; i++) {
       DCHECK(i->first <= source_frame_number);
+      for (auto& msg : i->second) {
+        routing_ids.insert(msg->routing_id());
+      }
+    }
+    return routing_ids;
+  }
+
+  void OnDidSwap(int source_frame_number,
+                 ScopedVector<IPC::Message>* messages) override {
+    DeliverSwapInfo(GetRoutingIDs(source_frame_number), source_frame_number,
+                    true, messages);
+    DrainMessages(source_frame_number, messages);
+  }
+
+  void OnDidNotSwap(int source_frame_number,
+                    cc::SwapPromise::DidNotSwapReason reason,
+                    ScopedVector<IPC::Message>* messages) override {
+    bool swap_ok;
+    switch (reason) {
+      case cc::SwapPromise::SWAP_FAILS:
+      case cc::SwapPromise::COMMIT_NO_UPDATE:
+        swap_ok = true;
+        break;
+      case cc::SwapPromise::COMMIT_FAILS:
+        swap_ok = false;
+        break;
+      default:
+        swap_ok = false;
+        NOTREACHED();
+    }
+    DeliverSwapInfo(GetRoutingIDs(source_frame_number), source_frame_number,
+                    swap_ok, messages);
+    DrainMessages(source_frame_number, messages);
+  }
+
+  void OnDrainMessages(ScopedVector<IPC::Message>* messages) override {}
+
+ private:
+  void DrainMessages(int source_frame_number,
+                     ScopedVector<IPC::Message>* messages) {
+    VisualStateQueueMap::iterator end = queue_.upper_bound(source_frame_number);
+    for (VisualStateQueueMap::iterator i = queue_.begin(); i != end; i++) {
+      DCHECK(i->first <= source_frame_number);
       messages->insert(messages->end(), i->second.begin(), i->second.end());
       i->second.clear();
     }
     queue_.erase(queue_.begin(), end);
   }
 
- private:
-  typedef std::map<int, std::vector<IPC::Message*> > VisualStateQueueMap;
+  typedef std::map<int, std::vector<IPC::Message*>> VisualStateQueueMap;
   VisualStateQueueMap queue_;
 
   DISALLOW_COPY_AND_ASSIGN(VisualStateQueue);
 };
 
 // Queue specific to MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP.
 class SwapQueue : public FrameSwapMessageSubQueue {
  public:
   SwapQueue() {}
   bool Empty() const override { return queue_.empty(); }
 
   void QueueMessage(int source_frame_number,
                     scoped_ptr<IPC::Message> msg,
                     bool* is_first) override {
     if (is_first)
       *is_first = Empty();
     queue_.push_back(msg.release());
   }
 
+  void OnDrainMessages(ScopedVector<IPC::Message>* messages) override {
+    DrainMessages(0, messages);
+  }
+
+  virtual void OnDidSwap(int source_frame_number,
+                         ScopedVector<IPC::Message>* messages) {
+  }
+
+  virtual void OnDidNotSwap(int source_frame_number,
+                            cc::SwapPromise::DidNotSwapReason reason,
+                            ScopedVector<IPC::Message>* messages) {
+    switch (reason) {
+      case cc::SwapPromise::SWAP_FAILS:
+      case cc::SwapPromise::COMMIT_NO_UPDATE:
+        DrainMessages(source_frame_number, messages);
+        break;
+      case cc::SwapPromise::COMMIT_FAILS:
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+ private:
   void DrainMessages(int source_frame_number,
-                     ScopedVector<IPC::Message>* messages) override {
+                     ScopedVector<IPC::Message>* messages) {
     messages->insert(messages->end(), queue_.begin(), queue_.end());
     queue_.weak_clear();
   }
 
- private:
   ScopedVector<IPC::Message> queue_;
 
   DISALLOW_COPY_AND_ASSIGN(SwapQueue);
 };
 
 }  // namespace
 
 FrameSwapMessageQueue::FrameSwapMessageQueue()
     : visual_state_queue_(new VisualStateQueue()),
       swap_queue_(new SwapQueue()) {
@@ skipping 25 matching lines @@
 void FrameSwapMessageQueue::QueueMessageForFrame(MessageDeliveryPolicy policy,
                                                  int source_frame_number,
                                                  scoped_ptr<IPC::Message> msg,
                                                  bool* is_first) {
   base::AutoLock lock(lock_);
   GetSubQueue(policy)->QueueMessage(source_frame_number, msg.Pass(), is_first);
 }
 
 void FrameSwapMessageQueue::DidSwap(int source_frame_number) {
   base::AutoLock lock(lock_);
-
-  visual_state_queue_->DrainMessages(source_frame_number,
-                                     &next_drain_messages_);
+  swap_queue_->OnDidSwap(source_frame_number, &next_drain_messages_);
+  visual_state_queue_->OnDidSwap(source_frame_number, &next_drain_messages_);
 }
 
 void FrameSwapMessageQueue::DidNotSwap(int source_frame_number,
                                        cc::SwapPromise::DidNotSwapReason reason,
                                        ScopedVector<IPC::Message>* messages) {
   base::AutoLock lock(lock_);
-  switch (reason) {
-    case cc::SwapPromise::SWAP_FAILS:
-    case cc::SwapPromise::COMMIT_NO_UPDATE:
-      swap_queue_->DrainMessages(source_frame_number, messages);
-    // fallthrough
-    case cc::SwapPromise::COMMIT_FAILS:
-      visual_state_queue_->DrainMessages(source_frame_number, messages);
-      break;
-    default:
-      NOTREACHED();
-  }
+  swap_queue_->OnDidNotSwap(source_frame_number, reason, messages);
+  visual_state_queue_->OnDidNotSwap(source_frame_number, reason, messages);
 }
 
 void FrameSwapMessageQueue::DrainMessages(
     ScopedVector<IPC::Message>* messages) {
   lock_.AssertAcquired();
 
-  swap_queue_->DrainMessages(0, messages);
-  messages->insert(messages->end(),
-                   next_drain_messages_.begin(),
+  swap_queue_->OnDrainMessages(messages);
+  visual_state_queue_->OnDrainMessages(messages);
+  messages->insert(messages->end(), next_drain_messages_.begin(),
                    next_drain_messages_.end());
   next_drain_messages_.weak_clear();
 }
 
 scoped_ptr<FrameSwapMessageQueue::SendMessageScope>
 FrameSwapMessageQueue::AcquireSendMessageScope() {
   return make_scoped_ptr(new SendMessageScopeImpl(&lock_));
 }
 
 // static
 void FrameSwapMessageQueue::TransferMessages(ScopedVector<IPC::Message>& source,
                                              vector<IPC::Message>* dest) {
   for (vector<IPC::Message*>::iterator i = source.begin(); i != source.end();
        ++i) {
     IPC::Message* m(*i);
     dest->push_back(*m);
     delete m;
   }
   source.weak_clear();
 }
 
 }  // namespace content