Credential Manager: Renderer-side implementation.

chrome/renderer/chrome_content_renderer_client.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 "chrome/renderer/chrome_content_renderer_client.h"
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 56 matching lines @@
 #include "chrome/renderer/searchbox/search_bouncer.h"
 #include "chrome/renderer/searchbox/searchbox.h"
 #include "chrome/renderer/searchbox/searchbox_extension.h"
 #include "chrome/renderer/tts_dispatcher.h"
 #include "chrome/renderer/worker_permission_client_proxy.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/password_generation_agent.h"
 #include "components/dom_distiller/core/url_constants.h"
 #include "components/nacl/renderer/ppb_nacl_private_impl.h"
+#include "components/password_manager/content/renderer/credential_manager_client.h"
 #include "components/plugins/renderer/mobile_youtube_plugin.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "components/visitedlink/renderer/visitedlink_slave.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
@@ skipping 220 matching lines @@
 #if defined(FULL_SAFE_BROWSING)
   phishing_classifier_.reset(safe_browsing::PhishingClassifierFilter::Create());
 #endif
   prerender_dispatcher_.reset(new prerender::PrerenderDispatcher());
 #if defined(ENABLE_WEBRTC)
   webrtc_logging_message_filter_ = new WebRtcLoggingMessageFilter(
       content::RenderThread::Get()->GetIOMessageLoopProxy());
 #endif
   search_bouncer_.reset(new SearchBouncer());
 
+  // ChromeRenderViewTest::SetUp() creates its own CredentialManagerClient and

[vabr (Chromium), 2014/08/20 14:40:34]

It would be great if the production code did not know about tests at all. Checks
like this might hide a bug later. I'm not blocking this CL on removing this test
dependency (because it's currently just a minor thing, and I don't know how to
fix it), but if there is a chance to deal with the clashing
CredentialManagerClient instances in the test rather than in the prod. code, we
should do that.

[Ilya Sherman, 2014/08/21 00:11:21]

+1, especially since it doesn't look like the test version of the client is
actually used in the Chrome layer.

[Mike West, 2014/08/21 10:20:46]

This isn't something I invented; I lifted this model from both Spellcheck and
ExtensionDelegate's implementation (lines 290 and 300 above in the same method).
Autofill does something similar in ChromeRenderViewTest, but it's sneakier since
it's implemented as a RenderViewObserver.

I'll try to rearrange things a bit, but there are a number of browser tests that
don't set things up in a way that CredentialManager appreciates. I'm looking for
the least-bad way of enabling them without teaching unrelated tests about things
they shouldn't need to care about.

+  // injects it using SetCredentialManagerClientForTesting(). Don't overwrite
+  // it.
+  if (!credential_manager_client_) {
+    credential_manager_client_.reset(
+        new password_manager::CredentialManagerClient());
+  }
+
   thread->AddObserver(chrome_observer_.get());
   thread->AddObserver(extension_dispatcher_.get());
 #if defined(FULL_SAFE_BROWSING)
   thread->AddObserver(phishing_classifier_.get());
 #endif
   thread->AddObserver(visited_link_slave_.get());
   thread->AddObserver(prerender_dispatcher_.get());
   thread->AddObserver(search_bouncer_.get());
+  thread->AddObserver(credential_manager_client_.get());
 
 #if defined(ENABLE_WEBRTC)
   thread->AddFilter(webrtc_logging_message_filter_.get());
 #endif
   thread->AddFilter(new CastIPCDispatcher(
       content::RenderThread::Get()->GetIOMessageLoopProxy()));
 
   thread->RegisterExtension(extensions_v8::ExternalExtension::Get());
   thread->RegisterExtension(extensions_v8::LoadTimesExtension::Get());
 
@@ skipping 151 matching lines @@
       new PasswordAutofillAgent(render_view);
   new AutofillAgent(render_view,
                     password_autofill_agent,
                     password_generation_agent);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kInstantProcess))
     new SearchBox(render_view);
 
   new ChromeRenderViewObserver(render_view, chrome_observer_.get());
+
+  credential_manager_client_->OnRenderViewCreated(render_view);
 }
 
 void ChromeContentRendererClient::SetNumberOfViews(int number_of_views) {
   base::debug::SetCrashKeyValue(crash_keys::kNumberOfViews,
                                 base::IntToString(number_of_views));
 }
 
 SkBitmap* ChromeContentRendererClient::GetSadPluginBitmap() {
   return const_cast<SkBitmap*>(ResourceBundle::GetSharedInstance().
       GetImageNamed(IDR_SAD_PLUGIN).ToSkBitmap());
@@ skipping 793 matching lines @@
 bool ChromeContentRendererClient::ShouldOverridePageVisibilityState(
     const content::RenderFrame* render_frame,
     blink::WebPageVisibilityState* override_state) {
   if (!prerender::PrerenderHelper::IsPrerendering(render_frame))
     return false;
 
   *override_state = blink::WebPageVisibilityStatePrerender;
   return true;
 }
 
+void ChromeContentRendererClient::SetCredentialManagerClientForTest(
+    password_manager::CredentialManagerClient* client) {
+  credential_manager_client_.reset(client);
+}
+
 void ChromeContentRendererClient::SetExtensionDispatcherForTest(
     extensions::Dispatcher* extension_dispatcher) {
   extension_dispatcher_.reset(extension_dispatcher);
   permissions_policy_delegate_.reset(
       new extensions::RendererPermissionsPolicyDelegate(
           extension_dispatcher_.get()));
 }
 
 extensions::Dispatcher*
 ChromeContentRendererClient::GetExtensionDispatcherForTest() {
@@ skipping 187 matching lines @@
 
   if (IsExtensionOrSharedModuleWhitelisted(url, allowed_video_decode_origins_))
     return true;
 
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   return channel <= chrome::VersionInfo::CHANNEL_DEV;
 #else
   return false;
 #endif
 }