Ensure that Service Worker clients are always returned in MRU order (1)

content/browser/service_worker/service_worker_version.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 "content/browser/service_worker/service_worker_version.h"
 
+#include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 353 matching lines @@
 void AddNonWindowClient(ServiceWorkerProviderHost* host,
                         const ServiceWorkerClientQueryOptions& options,
                         ServiceWorkerClients* clients) {
   blink::WebServiceWorkerClientType host_client_type = host->client_type();
   if (host_client_type == blink::WebServiceWorkerClientTypeWindow)
     return;
   if (options.client_type != blink::WebServiceWorkerClientTypeAll &&
       options.client_type != host_client_type)
     return;
 
-  ServiceWorkerClientInfo client_info(
-      blink::WebPageVisibilityStateHidden,
-      false,  // is_focused
-      host->document_url(), REQUEST_CONTEXT_FRAME_TYPE_NONE, host_client_type);
+  ServiceWorkerClientInfo client_info(blink::WebPageVisibilityStateHidden,
+                                      false,  // is_focused
+                                      host->document_url(),
+                                      REQUEST_CONTEXT_FRAME_TYPE_NONE,
+                                      base::TimeTicks(), host_client_type);
   client_info.client_uuid = host->client_uuid();
   clients->push_back(client_info);
 }
 
 bool IsInstalled(ServiceWorkerVersion::Status status) {
   switch (status) {
     case ServiceWorkerVersion::NEW:
     case ServiceWorkerVersion::INSTALLING:
     case ServiceWorkerVersion::REDUNDANT:
       return false;
     case ServiceWorkerVersion::INSTALLED:
     case ServiceWorkerVersion::ACTIVATING:
     case ServiceWorkerVersion::ACTIVATED:
       return true;
   }
   NOTREACHED() << "Unexpected status: " << status;
   return false;
 }
 
+struct ServiceWorkerClientInfoSortMRU {
+  bool operator()(const ServiceWorkerClientInfo& a,
+                  const ServiceWorkerClientInfo& b) const {
+    return a.last_focus_time > b.last_focus_time;
+  }
+};
+
 }  // namespace
 
 const int ServiceWorkerVersion::kStartWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 
 class ServiceWorkerVersion::Metrics {
  public:
   using EventType = ServiceWorkerMetrics::EventType;
   explicit Metrics(ServiceWorkerVersion* owner) : owner_(owner) {}
   ~Metrics() {
@@ skipping 853 matching lines @@
 }
 
 void ServiceWorkerVersion::OnGetClients(
     int request_id,
     const ServiceWorkerClientQueryOptions& options) {
   TRACE_EVENT_ASYNC_BEGIN2(
       "ServiceWorker", "ServiceWorkerVersion::OnGetClients", request_id,
       "client_type", options.client_type, "include_uncontrolled",
       options.include_uncontrolled);
 
+  ServiceWorkerClients clients;
   if (controllee_map_.empty() && !options.include_uncontrolled) {
-    OnGetClientsFinished(request_id, std::vector<ServiceWorkerClientInfo>());
+    OnGetClientsFinished(request_id, &clients);
     return;
   }
 
   // For Window clients we want to query the info on the UI thread first.
   if (options.client_type == blink::WebServiceWorkerClientTypeWindow ||
       options.client_type == blink::WebServiceWorkerClientTypeAll) {
     GetWindowClients(request_id, options);
     return;
   }
 
-  ServiceWorkerClients clients;
   GetNonWindowClients(request_id, options, &clients);
-  OnGetClientsFinished(request_id, clients);
+  OnGetClientsFinished(request_id, &clients);
 }
 
-void ServiceWorkerVersion::OnGetClientsFinished(
-    int request_id,
-    const ServiceWorkerClients& clients) {
+void ServiceWorkerVersion::OnGetClientsFinished(int request_id,
+                                                ServiceWorkerClients* clients) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClients",
-                         request_id, "The number of clients", clients.size());
+                         request_id, "The number of clients", clients->size());
 
   if (running_status() != RUNNING)
     return;
+  // Sort clients so that the most recently active tab is in the front.
+  std::sort(clients->begin(), clients->end(), ServiceWorkerClientInfoSortMRU());
   embedded_worker_->SendMessage(
-      ServiceWorkerMsg_DidGetClients(request_id, clients));
+      ServiceWorkerMsg_DidGetClients(request_id, *clients));
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnActivateEventFinished");
 
@@ skipping 598 matching lines @@
   return clients_info;
 }
 
 void ServiceWorkerVersion::DidGetWindowClients(
     int request_id,
     const ServiceWorkerClientQueryOptions& options,
     scoped_ptr<ServiceWorkerClients> clients) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (options.client_type == blink::WebServiceWorkerClientTypeAll)
     GetNonWindowClients(request_id, options, clients.get());
-  OnGetClientsFinished(request_id, *clients);
+  OnGetClientsFinished(request_id, clients.get());
 }
 
 void ServiceWorkerVersion::GetNonWindowClients(
     int request_id,
     const ServiceWorkerClientQueryOptions& options,
     ServiceWorkerClients* clients) {
   if (!options.include_uncontrolled) {
     for (auto& controllee : controllee_map_) {
       AddNonWindowClient(controllee.second, options, clients);
     }
@@ skipping 367 matching lines @@
                     base::string16());
   service_port_dispatcher_.reset();
 }
 
 void ServiceWorkerVersion::OnBackgroundSyncDispatcherConnectionError() {
   RunIDMapCallbacks(&sync_requests_, SERVICE_WORKER_ERROR_FAILED);
   background_sync_dispatcher_.reset();
 }
 
 }  // namespace content