Remove support for the keygen tag

content/browser/renderer_host/render_message_filter.cc

 // Copyright (c) 2012 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/renderer_host/render_message_filter.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include <map>
@@ skipping 43 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/url_constants.h"
 #include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/base/media_log_event.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "net/base/io_buffer.h"
-#include "net/base/keygen_handler.h"
 #include "net/base/mime_util.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_MACOSX)
@@ skipping 99 matching lines @@
     IPC_MESSAGE_HANDLER_GENERIC(
         ViewHostMsg_SetNeedsBeginFrames,
         ResizeHelperPostMsgToUIThread(render_process_id_, message))
 #endif
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ChildProcessHostMsg_HasGpuProcess,
                                     OnHasGpuProcess)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SetThreadPriority,
                         OnSetThreadPriority)
 #endif
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(RenderProcessHostMsg_Keygen, OnKeygen)
     IPC_MESSAGE_HANDLER(RenderProcessHostMsg_DidGenerateCacheableMetadata,
                         OnCacheableMetadataAvailable)
     IPC_MESSAGE_HANDLER(
         RenderProcessHostMsg_DidGenerateCacheableMetadataInCacheStorage,
         OnCacheableMetadataAvailableForCacheStorage)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(RenderProcessHostMsg_LoadFont, OnLoadFont)
 #endif
     IPC_MESSAGE_HANDLER(ViewHostMsg_MediaLogEvents, OnMediaLogEvents)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 203 matching lines @@
   if (error != CACHE_STORAGE_OK || !cache_handle || !cache_handle->value())
     return;
   CacheStorageCache* cache = cache_handle->value();
   if (!cache)
     return;
   cache->WriteSideData(base::Bind(&NoOpCacheStorageErrorCallback,
                                   base::Passed(std::move(cache_handle))),
                        url, expected_response_time, buf, buf_len);
 }
 
-void RenderMessageFilter::OnKeygen(uint32_t key_size_index,
-                                   const std::string& challenge_string,
-                                   const GURL& url,
-                                   const GURL& top_origin,
-                                   IPC::Message* reply_msg) {
-  if (!resource_context_)
-    return;
-
-  // Map displayed strings indicating level of keysecurity in the <keygen>
-  // menu to the key size in bits. (See SSLKeyGeneratorChromium.cpp in WebCore.)
-  int key_size_in_bits;
-  switch (key_size_index) {
-    case 0:
-      key_size_in_bits = 2048;
-      break;
-    case 1:
-      key_size_in_bits = 1024;
-      break;
-    default:
-      DCHECK(false) << "Illegal key_size_index " << key_size_index;
-      RenderProcessHostMsg_Keygen::WriteReplyParams(reply_msg, std::string());
-      Send(reply_msg);
-      return;
-  }
-
-  if (!GetContentClient()->browser()->AllowKeygen(top_origin,
-                                                  resource_context_)) {
-    RenderProcessHostMsg_Keygen::WriteReplyParams(reply_msg, std::string());
-    Send(reply_msg);
-    return;
-  }
-
-  resource_context_->CreateKeygenHandler(
-      key_size_in_bits,
-      challenge_string,
-      url,
-      base::Bind(
-          &RenderMessageFilter::PostKeygenToWorkerThread, this, reply_msg));
-}
-
-void RenderMessageFilter::PostKeygenToWorkerThread(
-    IPC::Message* reply_msg,
-    std::unique_ptr<net::KeygenHandler> keygen_handler) {
-  VLOG(1) << "Dispatching keygen task to worker pool.";
-  // Dispatch to worker pool, so we do not block the IO thread.
-  if (!base::WorkerPool::PostTask(
-           FROM_HERE,
-           base::Bind(&RenderMessageFilter::OnKeygenOnWorkerThread,
-                      this,
-                      base::Passed(&keygen_handler),
-                      reply_msg),
-           true)) {
-    NOTREACHED() << "Failed to dispatch keygen task to worker pool";
-    RenderProcessHostMsg_Keygen::WriteReplyParams(reply_msg, std::string());
-    Send(reply_msg);
-  }
-}
-
-void RenderMessageFilter::OnKeygenOnWorkerThread(
-    std::unique_ptr<net::KeygenHandler> keygen_handler,
-    IPC::Message* reply_msg) {
-  DCHECK(reply_msg);
-
-  // Generate a signed public key and challenge, then send it back.
-  RenderProcessHostMsg_Keygen::WriteReplyParams(
-      reply_msg,
-      keygen_handler->GenKeyAndSignChallenge());
-  Send(reply_msg);
-}
-
 void RenderMessageFilter::OnMediaLogEvents(
     const std::vector<media::MediaLogEvent>& events) {
   // OnMediaLogEvents() is always dispatched to the UI thread for handling.
   // See OverrideThreadForMessage().
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (media_internals_)
     media_internals_->OnMediaEvents(render_process_id_, events);
 }
 
 void RenderMessageFilter::OnHasGpuProcess(IPC::Message* reply_ptr) {
   std::unique_ptr<IPC::Message> reply(reply_ptr);
   GpuProcessHost::GetProcessHandles(
       base::Bind(&RenderMessageFilter::GetGpuProcessHandlesCallback,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&reply)));
 }
 
 void RenderMessageFilter::GetGpuProcessHandlesCallback(
     std::unique_ptr<IPC::Message> reply,
     const std::list<base::ProcessHandle>& handles) {
   bool has_gpu_process = handles.size() > 0;
   ChildProcessHostMsg_HasGpuProcess::WriteReplyParams(reply.get(),
                                                       has_gpu_process);
   Send(reply.release());
 }
 
 }  // namespace content