Revert of [DevTools] Migrate ServiceWorker domain to new generator.

content/browser/devtools/protocol/service_worker_handler.cc

 // Copyright 2015 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/devtools/protocol/service_worker_handler.h"
 
 #include "base/bind.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/common/push_messaging_status.h"
 #include "url/gurl.h"
 
 namespace content {
-namespace protocol {
+namespace devtools {
+namespace service_worker {
+
+using Response = DevToolsProtocolClient::Response;
 
 namespace {
 
 void ResultNoOp(bool success) {
 }
 
 void StatusNoOp(ServiceWorkerStatusCode status) {
 }
 
 void StatusNoOpKeepingRegistration(
     scoped_refptr<content::ServiceWorkerRegistration> protect,
     ServiceWorkerStatusCode status) {
 }
 
 void PushDeliveryNoOp(PushDeliveryStatus status) {
 }
 
 const std::string GetVersionRunningStatusString(
     EmbeddedWorkerStatus running_status) {
   switch (running_status) {
     case EmbeddedWorkerStatus::STOPPED:
-      return ServiceWorker::ServiceWorkerVersionRunningStatusEnum::Stopped;
+      return kServiceWorkerVersionRunningStatusStopped;
     case EmbeddedWorkerStatus::STARTING:
-      return ServiceWorker::ServiceWorkerVersionRunningStatusEnum::Starting;
+      return kServiceWorkerVersionRunningStatusStarting;
     case EmbeddedWorkerStatus::RUNNING:
-      return ServiceWorker::ServiceWorkerVersionRunningStatusEnum::Running;
+      return kServiceWorkerVersionRunningStatusRunning;
     case EmbeddedWorkerStatus::STOPPING:
-      return ServiceWorker::ServiceWorkerVersionRunningStatusEnum::Stopping;
-    default:
-      NOTREACHED();
+      return kServiceWorkerVersionRunningStatusStopping;
   }
   return std::string();
 }
 
 const std::string GetVersionStatusString(
     content::ServiceWorkerVersion::Status status) {
   switch (status) {
     case content::ServiceWorkerVersion::NEW:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::New;
+      return kServiceWorkerVersionStatusNew;
     case content::ServiceWorkerVersion::INSTALLING:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::Installing;
+      return kServiceWorkerVersionStatusInstalling;
     case content::ServiceWorkerVersion::INSTALLED:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::Installed;
+      return kServiceWorkerVersionStatusInstalled;
     case content::ServiceWorkerVersion::ACTIVATING:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::Activating;
+      return kServiceWorkerVersionStatusActivating;
     case content::ServiceWorkerVersion::ACTIVATED:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::Activated;
+      return kServiceWorkerVersionStatusActivated;
     case content::ServiceWorkerVersion::REDUNDANT:
-      return ServiceWorker::ServiceWorkerVersionStatusEnum::Redundant;
-    default:
-      NOTREACHED();
+      return kServiceWorkerVersionStatusRedundant;
   }
   return std::string();
 }
 
+scoped_refptr<ServiceWorkerVersion> CreateVersionDictionaryValue(
+    const ServiceWorkerVersionInfo& version_info) {
+  std::vector<std::string> clients;
+  for (const auto& client : version_info.clients) {
+    if (client.second.type == SERVICE_WORKER_PROVIDER_FOR_WINDOW) {
+      RenderFrameHostImpl* render_frame_host = RenderFrameHostImpl::FromID(
+          client.second.process_id, client.second.route_id);
+      WebContents* web_contents =
+          WebContents::FromRenderFrameHost(render_frame_host);
+      // There is a possibility that the frame is already deleted because of the
+      // thread hopping.
+      if (!web_contents)
+        continue;
+      scoped_refptr<DevToolsAgentHost> agent_host(
+          DevToolsAgentHost::GetOrCreateFor(web_contents));
+      if (agent_host)
+        clients.push_back(agent_host->GetId());
+    } else if (client.second.type ==
+               SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER) {
+      scoped_refptr<DevToolsAgentHost> agent_host(
+          DevToolsAgentHost::GetForWorker(client.second.process_id,
+                                          client.second.route_id));
+      if (agent_host)
+        clients.push_back(agent_host->GetId());
+    }
+  }
+  scoped_refptr<ServiceWorkerVersion> version(
+      ServiceWorkerVersion::Create()
+          ->set_version_id(base::Int64ToString(version_info.version_id))
+          ->set_registration_id(
+                base::Int64ToString(version_info.registration_id))
+          ->set_script_url(version_info.script_url.spec())
+          ->set_running_status(
+                GetVersionRunningStatusString(version_info.running_status))
+          ->set_status(GetVersionStatusString(version_info.status))
+          ->set_script_last_modified(
+                version_info.script_last_modified.ToDoubleT())
+          ->set_script_response_time(
+                version_info.script_response_time.ToDoubleT())
+          ->set_controlled_clients(clients));
+  scoped_refptr<DevToolsAgentHostImpl> host(
+      ServiceWorkerDevToolsManager::GetInstance()
+          ->GetDevToolsAgentHostForWorker(
+              version_info.process_id,
+              version_info.devtools_agent_route_id));
+  if (host)
+    version->set_target_id(host->GetId());
+  return version;
+}
+
+scoped_refptr<ServiceWorkerRegistration> CreateRegistrationDictionaryValue(
+    const ServiceWorkerRegistrationInfo& registration_info) {
+  scoped_refptr<ServiceWorkerRegistration> registration(
+      ServiceWorkerRegistration::Create()
+          ->set_registration_id(
+              base::Int64ToString(registration_info.registration_id))
+          ->set_scope_url(registration_info.pattern.spec())
+          ->set_is_deleted(registration_info.delete_flag ==
+                           ServiceWorkerRegistrationInfo::IS_DELETED));
+  return registration;
+}
+
 void StopServiceWorkerOnIO(scoped_refptr<ServiceWorkerContextWrapper> context,
                            int64_t version_id) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     version->StopWorker(base::Bind(&StatusNoOp));
   }
 }
 
 void GetDevToolsRouteInfoOnIO(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64_t version_id,
     const base::Callback<void(int, int)>& callback) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             callback, version->embedded_worker()->process_id(),
             version->embedded_worker()->worker_devtools_agent_route_id()));
   }
 }
 
 Response CreateContextErrorResponse() {
-  return Response::Error("Could not connect to the context");
+  return Response::InternalError("Could not connect to the context");
 }
 
 Response CreateInvalidVersionIdErrorResponse() {
-  return Response::InvalidParams("Invalid version ID");
+  return Response::InternalError("Invalid version ID");
 }
 
 void DidFindRegistrationForDispatchSyncEventOnIO(
     scoped_refptr<BackgroundSyncContext> sync_context,
     const std::string& tag,
     bool last_chance,
     ServiceWorkerStatusCode status,
     scoped_refptr<content::ServiceWorkerRegistration> registration) {
   if (status != SERVICE_WORKER_OK || !registration->active_version())
     return;
@@ skipping 19 matching lines @@
                  tag, last_chance));
 }
 
 }  // namespace
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), render_frame_host_(nullptr), weak_factory_(this) {
 }
 
 ServiceWorkerHandler::~ServiceWorkerHandler() {
-}
-
-void ServiceWorkerHandler::Wire(UberDispatcher* dispatcher) {
-  frontend_.reset(new ServiceWorker::Frontend(dispatcher->channel()));
-  ServiceWorker::Dispatcher::wire(dispatcher, this);
+  Disable();
 }
 
 void ServiceWorkerHandler::SetRenderFrameHost(
     RenderFrameHostImpl* render_frame_host) {
   render_frame_host_ = render_frame_host;
   // Do not call UpdateHosts yet, wait for load to commit.
   if (!render_frame_host) {
     ClearForceUpdate();
     context_ = nullptr;
     return;
   }
   StoragePartition* partition = BrowserContext::GetStoragePartition(
       render_frame_host->GetProcess()->GetBrowserContext(),
       render_frame_host->GetSiteInstance());
   DCHECK(partition);
   context_ = static_cast<ServiceWorkerContextWrapper*>(
       partition->GetServiceWorkerContext());
 }
 
+void ServiceWorkerHandler::SetClient(std::unique_ptr<Client> client) {
+  client_.swap(client);
+}
+
+void ServiceWorkerHandler::Detached() {
+  Disable();
+}
+
 Response ServiceWorkerHandler::Enable() {
   if (enabled_)
     return Response::OK();
   if (!context_)
-    return CreateContextErrorResponse();
+    return Response::InternalError("Could not connect to the context");
   enabled_ = true;
 
   context_watcher_ = new ServiceWorkerContextWatcher(
       context_, base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
                            weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceWorkerHandler::OnErrorReported,
                  weak_factory_.GetWeakPtr()));
   context_watcher_->Start();
@@ skipping 139 matching lines @@
   scoped_refptr<DevToolsAgentHostImpl> agent_host(
       ServiceWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(process_id, devtools_agent_route_id));
   if (!agent_host.get())
     return;
   agent_host->Inspect();
 }
 
 void ServiceWorkerHandler::OnWorkerRegistrationUpdated(
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
-  using Registration = ServiceWorker::ServiceWorkerRegistration;
-  std::unique_ptr<protocol::Array<Registration>> result =
-      protocol::Array<Registration>::create();
+  std::vector<scoped_refptr<ServiceWorkerRegistration>> registration_values;
   for (const auto& registration : registrations) {
-    result->addItem(Registration::Create()
-        .SetRegistrationId(
-            base::Int64ToString(registration.registration_id))
-        .SetScopeURL(registration.pattern.spec())
-        .SetIsDeleted(registration.delete_flag ==
-                      ServiceWorkerRegistrationInfo::IS_DELETED)
-        .Build());
+    registration_values.push_back(
+        CreateRegistrationDictionaryValue(registration));
   }
-  frontend_->WorkerRegistrationUpdated(std::move(result));
+  client_->WorkerRegistrationUpdated(
+      WorkerRegistrationUpdatedParams::Create()->set_registrations(
+          registration_values));
 }
 
 void ServiceWorkerHandler::OnWorkerVersionUpdated(
     const std::vector<ServiceWorkerVersionInfo>& versions) {
-  using Version = ServiceWorker::ServiceWorkerVersion;
-  std::unique_ptr<protocol::Array<Version>> result =
-      protocol::Array<Version>::create();
+  std::vector<scoped_refptr<ServiceWorkerVersion>> version_values;
   for (const auto& version : versions) {
-    std::unique_ptr<protocol::Array<std::string>> clients =
-        protocol::Array<std::string>::create();
-    for (const auto& client : version.clients) {
-      if (client.second.type == SERVICE_WORKER_PROVIDER_FOR_WINDOW) {
-        RenderFrameHostImpl* render_frame_host = RenderFrameHostImpl::FromID(
-            client.second.process_id, client.second.route_id);
-        WebContents* web_contents =
-            WebContents::FromRenderFrameHost(render_frame_host);
-        // There is a possibility that the frame is already deleted
-        // because of the thread hopping.
-        if (!web_contents)
-          continue;
-        clients->addItem(
-            DevToolsAgentHost::GetOrCreateFor(web_contents)->GetId());
-      } else if (client.second.type ==
-                 SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER) {
-        scoped_refptr<DevToolsAgentHost> agent_host(
-            DevToolsAgentHost::GetForWorker(client.second.process_id,
-                                            client.second.route_id));
-        if (agent_host)
-          clients->addItem(agent_host->GetId());
-      }
-    }
-    std::unique_ptr<Version> version_value = Version::Create()
-        .SetVersionId(base::Int64ToString(version.version_id))
-        .SetRegistrationId(
-            base::Int64ToString(version.registration_id))
-        .SetScriptURL(version.script_url.spec())
-        .SetRunningStatus(
-            GetVersionRunningStatusString(version.running_status))
-        .SetStatus(GetVersionStatusString(version.status))
-        .SetScriptLastModified(
-            version.script_last_modified.ToDoubleT())
-        .SetScriptResponseTime(
-            version.script_response_time.ToDoubleT())
-        .SetControlledClients(std::move(clients))
-        .Build();
-    scoped_refptr<DevToolsAgentHostImpl> host(
-        ServiceWorkerDevToolsManager::GetInstance()
-            ->GetDevToolsAgentHostForWorker(
-                version.process_id,
-                version.devtools_agent_route_id));
-    if (host)
-      version_value->SetTargetId(host->GetId());
-    result->addItem(std::move(version_value));
+    version_values.push_back(CreateVersionDictionaryValue(version));
   }
-  frontend_->WorkerVersionUpdated(std::move(result));
+  client_->WorkerVersionUpdated(
+      WorkerVersionUpdatedParams::Create()->set_versions(version_values));
 }
 
 void ServiceWorkerHandler::OnErrorReported(
     int64_t registration_id,
     int64_t version_id,
     const ServiceWorkerContextObserver::ErrorInfo& info) {
-  frontend_->WorkerErrorReported(
-      ServiceWorker::ServiceWorkerErrorMessage::Create()
-          .SetErrorMessage(base::UTF16ToUTF8(info.error_message))
-          .SetRegistrationId(base::Int64ToString(registration_id))
-          .SetVersionId(base::Int64ToString(version_id))
-          .SetSourceURL(info.source_url.spec())
-          .SetLineNumber(info.line_number)
-          .SetColumnNumber(info.column_number)
-          .Build());
+  client_->WorkerErrorReported(
+      WorkerErrorReportedParams::Create()->set_error_message(
+          ServiceWorkerErrorMessage::Create()
+              ->set_error_message(base::UTF16ToUTF8(info.error_message))
+              ->set_registration_id(base::Int64ToString(registration_id))
+              ->set_version_id(base::Int64ToString(version_id))
+              ->set_source_url(info.source_url.spec())
+              ->set_line_number(info.line_number)
+              ->set_column_number(info.column_number)));
 }
 
 void ServiceWorkerHandler::ClearForceUpdate() {
   if (context_)
     context_->SetForceUpdateOnPageLoad(false);
 }
 
-}  // namespace protocol
+}  // namespace service_worker
+}  // namespace devtools
 }  // namespace content