Refactor language detection logic to allow non-static CLD data sources.

components/translate/content/renderer/renderer_cld_data_provider.h

 // 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_H_
 #define COMPONENTS_TRANSLATE_CONTENT_RENDERER_RENDERER_CLD_DATA_PROVIDER_H_
 
 #include "base/callback.h"
 #include "ipc/ipc_listener.h"
 
 namespace IPC {
 class Message;
 }
 
-namespace content {
-class RenderViewObserver;
-}
-
 namespace translate {
 
 // Renderer-side interface responsible for providing CLD data.
 // The implementation must be paired with a browser-side implementation of
 // the BrowserCldDataProvider class:
 //
 //   components/translate/content/browser/browser_cld_data_provider.h
 //
 // ... and the glue between them is typically a pair of request/response IPC
 // messages using the CldDataProviderMsgStart IPCMessageStart enumerated
 // constant from ipc_message_start.h
 class RendererCldDataProvider : public IPC::Listener {
  public:
+  RendererCldDataProvider();
   virtual ~RendererCldDataProvider() {}
 
   // (Inherited from IPC::Listener)
   // If the specified message is a response for CLD data, attempts to
   // initialize CLD2 and returns true in all cases. If initialization is
   // successful and a callback has been configured via
   // SetCldAvailableCallback(...), that callback is invoked from the message
   // loop thread.
   // This method is defined as virtual in order to force the implementation to
   // define the specific IPC message(s) that it handles.
-  virtual bool OnMessageReceived(const IPC::Message&) = 0;
+  // The default implementation does nothing and returns false.
+  virtual bool OnMessageReceived(const IPC::Message&) override;
 
   // Invoked by the renderer process to request that CLD data be obtained and
   // that CLD be initialized with it. The implementation is expected to
   // communicate with the paired BrowserCldDataProvider implementation on the
   // browser side.
   // This method must be invoked on the message loop thread.
-  virtual void SendCldDataRequest() = 0;
+  // The default implementation does nothing.
+  virtual void SendCldDataRequest();
 
   // Convenience method that tracks whether or not CLD data is available.
   // This method can be used in the absence of a callback (i.e., if the caller
   // wants a simple way to check the state of CLD data availability without
   // keeping a separate boolean flag tripped by a callback).
-  virtual bool IsCldDataAvailable() = 0;
+  // The default implementation always returns true.
+  virtual bool IsCldDataAvailable();
 
   // Sets a callback that will be invoked when CLD data is successfully
   // obtained from the paired BrowserCldDataProvider implementation on the
   // browser side, after CLD has been successfully initialized.
   // Both the initialization of CLD2 as well as the invocation of the callback
   // must happen on the message loop thread.
-  virtual void SetCldAvailableCallback(base::Callback<void(void)>) = 0;
+  // The default implementation immediately invokes the callback.
+  virtual void SetCldAvailableCallback(base::Callback<void(void)>);
+
+  // Sets the instance of the provider used by this process, optionally
+  // overwriting the previous value. Embedders and narrow use-cases (such as
+  // shells and test code) should use the overwrite capability, while generic
+  // code should not.
+  // If another instance is already set, it is immediately destroyed prior to
+  // updating the global pointer to point to the specified instance.
+  static void Set(RendererCldDataProvider* instance, bool overwrite);
+
+  // 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();
 };

[jochen (gone - plz use gerrit), 2014/10/23 13:57:39]

disallow copy/assign

[Andrew Hayden (chromium.org), 2014/10/30 16:56:32]

Done.

 
-// Static factory function defined by the implementation that produces a new
-// provider for the specified render view host.
-RendererCldDataProvider* CreateRendererCldDataProviderFor(
-    content::RenderViewObserver*);
-
 }  // namespace translate
 
 #endif  // COMPONENTS_TRANSLATE_CONTENT_RENDERER_RENDERER_CLD_DATAP_PROVIDER_H_