Hopefully final set of changes needed to make it possible for embedders to

customize the CLD data source. Introduces a RendererCldDataProviderFactory that
is analogous to the BrowserCldDataProviderFactory; it was initially thought that
this would not be needed, but it allows embedders to statically configure the
factory anywhere on the render thread - by far the easiest way for the embedder
to integrate the desired implementation.

Also adds a bit of DVLOG to help runtime debugging of the data source. No other
significant changes.

BUG=

Review URL: https://codereview.chromium.org/728413002

Cr-Commit-Position: refs/heads/master@{#304581}

11 files changed, 164 insertions, 83 deletions

diff --git a/components/translate/content/browser/browser_cld_data_provider_factory.h b/components/translate/content/browser/browser_cld_data_provider_factory.h
index bae2250..a3ce2f5 100644
--- a/components/translate/content/browser/browser_cld_data_provider_factory.h
+++ b/components/translate/content/browser/browser_cld_data_provider_factory.h
@@ -55,8 +55,8 @@ class BrowserCldDataProviderFactory {
 
   // Returns the instance of the factory previously set by Set()/SetDefault().
   // If no instance has been set, a default factory will be returned that
-  // produces no-op BrowserCldDataProviders as described by NewProvider(...)
-  // above.
+  // produces no-op BrowserCldDataProviders as described by
+  // CreateBrowserCldDataProvider(...) above.
   static BrowserCldDataProviderFactory* Get();
 
  private:
diff --git a/components/translate/content/browser/browser_cld_utils.cc b/components/translate/content/browser/browser_cld_utils.cc
index 4e65c05..a143165 100644
--- a/components/translate/content/browser/browser_cld_utils.cc
+++ b/components/translate/content/browser/browser_cld_utils.cc
@@ -4,6 +4,7 @@
 
 #include "components/translate/content/browser/browser_cld_utils.h"
 
+#include "base/logging.h"
 #include "components/translate/content/browser/browser_cld_data_provider_factory.h"
 #include "components/translate/content/common/cld_data_source.h"
 
@@ -12,6 +13,7 @@ namespace translate {
 // static
 void BrowserCldUtils::ConfigureDefaultDataProvider() {
   if (!BrowserCldDataProviderFactory::IsInitialized()) {
+    DVLOG(1) << "Configuring default BrowserCldDataProviderFactory";
     BrowserCldDataProviderFactory* factory = NULL;
     CldDataSource* data_source = NULL;
 
diff --git a/components/translate/content/common/cld_data_source.h b/components/translate/content/common/cld_data_source.h
index 577c415f..90af0ce 100644
--- a/components/translate/content/common/cld_data_source.h
+++ b/components/translate/content/common/cld_data_source.h
@@ -53,13 +53,13 @@ class CldDataSource {
   // If the data source doesn't need or doesn't support such configuration, this
   // function is a no-op. This is the case for, e.g., the static data source.
   // This method is threadsafe.
-  void SetCldDataFilePath(const base::FilePath& path);
+  virtual void SetCldDataFilePath(const base::FilePath& path);
 
   // Returns the path most recently set by SetCldDataFilePath. The initial value
   // prior to any such call is the empty path. If the data source doesn't
   // support a data file, returns the empty path.
   // This method is threadsafe.
-  base::FilePath GetCldDataFilePath();
+  virtual base::FilePath GetCldDataFilePath();
 
   // Sets the default data source for this process, i.e. the data source to be
   // used unless the embedder calls Set(CldDatasource*). This is the method
diff --git a/components/translate/content/renderer/BUILD.gn b/components/translate/content/renderer/BUILD.gn
index 86440fc..af1ed91 100644
--- a/components/translate/content/renderer/BUILD.gn
+++ b/components/translate/content/renderer/BUILD.gn
@@ -8,6 +8,8 @@ static_library("renderer") {
   sources = [
     "data_file_renderer_cld_data_provider.cc",
     "data_file_renderer_cld_data_provider.h",
+    "renderer_cld_data_provider_factory.cc",
+    "renderer_cld_data_provider_factory.h",
     "renderer_cld_data_provider.cc",
     "renderer_cld_data_provider.h",
     "renderer_cld_utils.cc",
diff --git a/components/translate/content/renderer/renderer_cld_data_provider.cc b/components/translate/content/renderer/renderer_cld_data_provider.cc
index d97f3bc..b43901d 100644
--- a/components/translate/content/renderer/renderer_cld_data_provider.cc
+++ b/components/translate/content/renderer/renderer_cld_data_provider.cc
@@ -2,24 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/lazy_instance.h"
 #include "components/translate/content/renderer/renderer_cld_data_provider.h"
 
-namespace {
-
-// Our global default instance, alive for the entire lifetime of the process.
-translate::RendererCldDataProvider* g_instance = NULL;
-
-// The default factory, which produces no-op instances of
-// RendererCldDataProvider suitable for use when CLD data is statically-linked.
-base::LazyInstance<translate::RendererCldDataProvider>::Leaky
-g_wrapped_default = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-
 namespace translate {
 
+RendererCldDataProvider::RendererCldDataProvider() {
+  // Nothing
+}
+
 bool RendererCldDataProvider::IsCldDataAvailable() {
   return true;
 }
@@ -33,27 +23,4 @@ void RendererCldDataProvider::SetCldAvailableCallback
   callback.Run();
 }
 
-// static
-void RendererCldDataProvider::SetDefault(
-    RendererCldDataProvider* instance) {
-  if (!IsInitialized()) Set(instance);
-}
-
-// static
-void RendererCldDataProvider::Set(
-    RendererCldDataProvider* instance) {
-  g_instance = instance;
-}
-
-// static
-bool RendererCldDataProvider::IsInitialized() {
-  return g_instance != NULL;
-}
-
-// static
-RendererCldDataProvider* RendererCldDataProvider::Get() {
-  if (IsInitialized()) return g_instance;
-  return &g_wrapped_default.Get();
-}
-
 }  // namespace translate
diff --git a/components/translate/content/renderer/renderer_cld_data_provider.h b/components/translate/content/renderer/renderer_cld_data_provider.h
index 7d20bb7..b5ae4b7 100644
--- a/components/translate/content/renderer/renderer_cld_data_provider.h
+++ b/components/translate/content/renderer/renderer_cld_data_provider.h
@@ -28,7 +28,7 @@ namespace translate {
 // "IPCMessageStart" enumerated constant from ipc_message_start.h.
 class RendererCldDataProvider : public IPC::Listener {
  public:
-  RendererCldDataProvider() {}
+  RendererCldDataProvider();
   ~RendererCldDataProvider() override {}
 
   // (Inherited from IPC::Listener)
@@ -65,33 +65,6 @@ class RendererCldDataProvider : public IPC::Listener {
   // The default implementation immediately invokes the callback.
   virtual void SetCldAvailableCallback(base::Callback<void(void)> callback);
 
-  // Sets the default data provider for this process, i.e. the provider to be
-  // used unless the embedder calls Set(RendererCldDataProvider*). This is the
-  // method that normal (i.e., non-test) Chromium code should use; embedders can
-  // and should use the unconditional Set(RendererCldDataProvider*) method
-  // instead. If a default provider has already been set, this method does
-  // nothing.
-  static void SetDefault(RendererCldDataProvider* instance);
-
-  // Unconditionally sets the data provider for this process, overwriting any
-  // previously-configured default. Normal Chromium code should never use this
-  // method; it is provided for embedders to inject a provider from outside of
-  // the Chromium code base. Test code can also use this method to force the
-  // runtime to have a desired behavior.
-  //
-  // The caller is responsible for the lifecycle of the instance. In general,
-  // the instance passed here should live throughout the lifetime of the
-  // process.
-  static void Set(RendererCldDataProvider* instance);
-
-  // Returns true if and only if the current instance for this process is not
-  // NULL.
-  static bool IsInitialized();
-
-  // Returns the instance of the provider previously set by Set(...).
-  // If no instance has been set, a default no-op provider will be returned.
-  static RendererCldDataProvider* Get();
-
  private:
   DISALLOW_COPY_AND_ASSIGN(RendererCldDataProvider);
 };
diff --git a/components/translate/content/renderer/renderer_cld_data_provider_factory.cc b/components/translate/content/renderer/renderer_cld_data_provider_factory.cc
new file mode 100644
index 0000000..3b3dc36
--- /dev/null
+++ b/components/translate/content/renderer/renderer_cld_data_provider_factory.cc
@@ -0,0 +1,56 @@
+// 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 "components/translate/content/renderer/renderer_cld_data_provider_factory.h"
+
+#include "base/lazy_instance.h"
+#include "components/translate/content/renderer/renderer_cld_data_provider.h"
+#include "content/public/renderer/render_view_observer.h"
+
+namespace {
+
+// The global instance, alive for the entire lifetime of the process.
+translate::RendererCldDataProviderFactory* g_instance = NULL;
+
+// The default factory, which produces no-op instances of
+// RendererCldDataProvider suitable for use when CLD data is statically-linked.
+base::LazyInstance<translate::RendererCldDataProviderFactory>::Leaky
+  g_wrapped_default = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+
+namespace translate {
+
+scoped_ptr<RendererCldDataProvider>
+RendererCldDataProviderFactory::CreateRendererCldDataProvider(
+    content::RenderViewObserver* render_view_observer) {
+  return scoped_ptr<RendererCldDataProvider>(
+      new RendererCldDataProvider());
+}
+
+// static
+bool RendererCldDataProviderFactory::IsInitialized() {
+  return g_instance != NULL;
+}
+
+// static
+void RendererCldDataProviderFactory::SetDefault(
+    RendererCldDataProviderFactory* instance) {
+  if (!IsInitialized()) Set(instance);
+}
+
+// static
+void RendererCldDataProviderFactory::Set(
+    RendererCldDataProviderFactory* instance) {
+    g_instance = instance;
+}
+
+// static
+RendererCldDataProviderFactory* RendererCldDataProviderFactory::Get() {
+  if (IsInitialized()) return g_instance;
+  return &g_wrapped_default.Get();
+}
+
+}  // namespace translate
diff --git a/components/translate/content/renderer/renderer_cld_data_provider_factory.h b/components/translate/content/renderer/renderer_cld_data_provider_factory.h
new file mode 100644
index 0000000..3cc7fa2
--- /dev/null
+++ b/components/translate/content/renderer/renderer_cld_data_provider_factory.h
@@ -0,0 +1,68 @@
+// 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.
+
+#ifndef COMPONENTS_TRANSLATE_CONTENT_RENDERER_RENDERER_CLD_DATA_PROVIDER_FACTORY_H_
+#define COMPONENTS_TRANSLATE_CONTENT_RENDERER_RENDERER_CLD_DATA_PROVIDER_FACTORY_H_
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "components/translate/content/renderer/renderer_cld_data_provider.h"
+
+namespace content {
+class RenderViewObserver;
+}
+
+namespace translate {
+
+// A factory for the Renderer side of CLD Data Providers. The embedder should
+// set an instance as soon as feasible during startup. The renderer process will
+// use this factory to create the one RendererCldDataProvider for each render
+// view in order to communicate with a BrowserCldDataProvider in the browser
+// process. For more information on the RendererCldDataProvider, see:
+//   ../renderer/renderer_cld_data_provider.h
+class RendererCldDataProviderFactory {
+ public:
+  RendererCldDataProviderFactory() {}
+  virtual ~RendererCldDataProviderFactory() {}
+
+  // Create and return a new instance of a RendererCldDataProvider. The default
+  // implementation of this method produces a no-op RendererCldDataProvider that
+  // is suitable only when CLD data has been statically linked.
+  // Every invocation creates a new provider; the caller is responsible for
+  // deleting the object when it is no longer needed.
+  virtual scoped_ptr<RendererCldDataProvider> CreateRendererCldDataProvider(
+      content::RenderViewObserver* render_view_observer);
+
+  // Returns true if and only if the current instance for this process is not
+  // NULL.
+  static bool IsInitialized();
+
+  // Sets the default factory for this process, i.e. the factory to be used
+  // unless the embedder calls Set(RendererCldDataProviderFactory*). This is the
+  // method that normal (i.e., non-test) Chromium code should use; embedders can
+  // and should use the unconditional Set(RendererCldDataProviderFactory*)
+  // method instead. If a default factory has already been set, this method does
+  // nothing.
+  static void SetDefault(RendererCldDataProviderFactory* instance);
+
+  // Unconditionally sets the factory for this process, overwriting any
+  // previously-configured default. Normal Chromium code should never use this
+  // method; it is provided for embedders to inject a factory from outside of
+  // the Chromium code base. Test code can also use this method to force the
+  // runtime to have a desired behavior.
+  static void Set(RendererCldDataProviderFactory* instance);
+
+  // Returns the instance of the factory previously set by Set()/SetDefault().
+  // If no instance has been set, a default factory will be returned that
+  // produces no-op RendererCldDataProviders as described by
+  // CreateRendererCldDataProvider(...) above.
+  static RendererCldDataProviderFactory* Get();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RendererCldDataProviderFactory);
+};
+
+}  // namespace translate
+
+#endif  // COMPONENTS_TRANSLATE_CONTENT_RENDERER_RENDERER_CLD_DATA_PROVIDER_FACTORY_H_
diff --git a/components/translate/content/renderer/renderer_cld_utils.cc b/components/translate/content/renderer/renderer_cld_utils.cc
index 210b977..aaa9728 100644
--- a/components/translate/content/renderer/renderer_cld_utils.cc
+++ b/components/translate/content/renderer/renderer_cld_utils.cc
@@ -4,15 +4,18 @@
 
 #include "components/translate/content/renderer/renderer_cld_utils.h"
 
+#include "base/logging.h"
 #include "components/translate/content/common/cld_data_source.h"
 #include "components/translate/content/renderer/renderer_cld_data_provider.h"
+#include "components/translate/content/renderer/renderer_cld_data_provider_factory.h"
 
 namespace translate {
 
 // static
 void RendererCldUtils::ConfigureDefaultDataProvider() {
-  if (!RendererCldDataProvider::IsInitialized()) {
-    RendererCldDataProvider* provider = NULL;
+  if (!RendererCldDataProviderFactory::IsInitialized()) {
+    DVLOG(1) << "Configuring default RendererCldDataProviderFactory";
+    RendererCldDataProviderFactory* factory = NULL;
     CldDataSource* data_source = NULL;
 
     // Maintainers: Customize platform defaults here as necessary.
@@ -26,12 +29,12 @@ void RendererCldUtils::ConfigureDefaultDataProvider() {
     // - For any other sources, the embedder should already have set a provider
     //   and so this code should never be invoked.
     // -----------------------------------------------------------------------
-    provider = new RendererCldDataProvider();
+    factory = new RendererCldDataProviderFactory();
     data_source = CldDataSource::GetStaticDataSource();
     // -----------------------------------------------------------------------
 
     // Apply the values defined above
-    RendererCldDataProvider::SetDefault(provider);
+    RendererCldDataProviderFactory::SetDefault(factory);
     CldDataSource::SetDefault(data_source);
   }
 }
diff --git a/components/translate/content/renderer/translate_helper.cc b/components/translate/content/renderer/translate_helper.cc
index e2da2f9..0e0f4c7 100644
--- a/components/translate/content/renderer/translate_helper.cc
+++ b/components/translate/content/renderer/translate_helper.cc
@@ -14,6 +14,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/content/renderer/renderer_cld_data_provider.h"
+#include "components/translate/content/renderer/renderer_cld_data_provider_factory.h"
 #include "components/translate/content/renderer/renderer_cld_utils.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
@@ -70,6 +71,16 @@ const char kContentSecurityPolicy[] = "script-src 'self' 'unsafe-eval'";
 // Whether or not we have set the CLD callback yet.
 bool g_cld_callback_set = false;
 
+// Obtain a new CLD data provider. Defined as a standalone method for ease of
+// use in constructor initialization list.
+scoped_ptr<translate::RendererCldDataProvider> CreateDataProvider(
+    content::RenderViewObserver* render_view_observer) {
+  translate::RendererCldUtils::ConfigureDefaultDataProvider();
+  return scoped_ptr<translate::RendererCldDataProvider>(
+      translate::RendererCldDataProviderFactory::Get()->
+      CreateRendererCldDataProvider(render_view_observer));
+}
+
 }  // namespace
 
 namespace translate {
@@ -84,8 +95,7 @@ TranslateHelper::TranslateHelper(content::RenderView* render_view,
     : content::RenderViewObserver(render_view),
       page_seq_no_(0),
       translation_pending_(false),
-      cld_data_provider_(
-          static_cast<translate::RendererCldDataProvider*>(NULL)),
+      cld_data_provider_(CreateDataProvider(this)),
       cld_data_polling_started_(false),
       cld_data_polling_canceled_(false),
       deferred_page_capture_(false),
@@ -94,8 +104,6 @@ TranslateHelper::TranslateHelper(content::RenderView* render_view,
       extension_group_(extension_group),
       extension_scheme_(extension_scheme),
       weak_method_factory_(this) {
-  translate::RendererCldUtils::ConfigureDefaultDataProvider();
-  cld_data_provider_ = translate::RendererCldDataProvider::Get();
 }
 
 TranslateHelper::~TranslateHelper() {
@@ -570,12 +578,16 @@ void TranslateHelper::CancelCldDataPolling() {
 void TranslateHelper::SendCldDataRequest(const int delay_millis,
                                          const int next_delay_millis) {
   // Terminate immediately if told to stop polling.
-  if (cld_data_polling_canceled_)
+  if (cld_data_polling_canceled_) {
+    DVLOG(1) << "Aborting CLD data request (polling canceled)";
     return;
+  }
 
   // Terminate immediately if data is already loaded.
-  if (cld_data_provider_->IsCldDataAvailable())
+  if (cld_data_provider_->IsCldDataAvailable()) {
+    DVLOG(1) << "Aborting CLD data request (data available)";
     return;
+  }
 
   if (!g_cld_callback_set) {
     g_cld_callback_set = true;
@@ -585,6 +597,7 @@ void TranslateHelper::SendCldDataRequest(const int delay_millis,
   }
 
   // Else, make an asynchronous request to get the data we need.
+  DVLOG(1) << "Requesting CLD data from data provider";
   cld_data_provider_->SendCldDataRequest();
 
   // ... and enqueue another delayed task to call again. This will start a
diff --git a/components/translate/content/renderer/translate_helper.h b/components/translate/content/renderer/translate_helper.h
index 696217c..4d9275d 100644
--- a/components/translate/content/renderer/translate_helper.h
+++ b/components/translate/content/renderer/translate_helper.h
@@ -244,10 +244,7 @@ class TranslateHelper : public content::RenderViewObserver {
   base::TimeTicks language_determined_time_;
 
   // Provides CLD data for this process.
-  // The pointer is owned by the global in RendererCldDataProvider and has the
-  // same lifetime as the process itself, so this field is simply a raw pointer
-  // instead of a scoped_ptr.
-  RendererCldDataProvider* cld_data_provider_;
+  scoped_ptr<RendererCldDataProvider> cld_data_provider_;
 
   // Whether or not polling for CLD2 data has started.
   bool cld_data_polling_started_;