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

components/translate/content/common/cld_data_source.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_COMMON_CLD_DATA_SOURCE_H_
 #define COMPONENTS_TRANSLATE_CONTENT_COMMON_CLD_DATA_SOURCE_H_
 
 #include <string>
 
+#include "base/files/file_path.h"
+#include "base/synchronization/lock.h"
+
 namespace translate {
 
 // Provides high-level functionality related to a CLD Data Source.
 class CldDataSource {
 
  public:
+  CldDataSource(std::string name,
+                bool register_for_component_updates,
+                bool use_standalone_data_file);
+  virtual ~CldDataSource() {}
 
   // Returns the symbolic name of the data source. In the Chromium
   // open-source tree, the following data sources exist:
   // static       uses the static_[browser|renderer]_cld_data_provider
   //              implementations.
   // standalone   uses the data_file_[browser|renderer]_cld_data_provider
   //              implementations.
   // component    also uses the data_file_[browser|renderer]_cld_data_provider
   //              implementations.
   //
   // Other implementations based upon Chromium may provide CLD differently and
   // may have other names. This method is primarily provided for those
   // non-Chromium implementations; Chromium implementations should use the
   // boolean methods in this class instead:
   // ShouldRegisterForComponentUpdates()
   // ShouldUseStandaloneDataFile()
-  static std::string GetName();
+  virtual std::string GetName();
 
   // Returns true if the data source needs to receive updates from the
   // Component Updater.
   // This is only true if the data source name is "component", but makes caller
   // logic more generic.
-  static bool ShouldRegisterForComponentUpdates();
+  virtual bool ShouldRegisterForComponentUpdates();
 
   // Returns true if the data source needs to have the path to the CLD
   // data file configured immediately because it is bundled with Chromium.
   // This is only true if the data source name is "standalone", but makes
   // caller logic more generic.
-  static bool ShouldUseStandaloneDataFile();
+  virtual bool ShouldUseStandaloneDataFile();
+
+  // For data sources that support a separate CLD data file, configures the path
+  // of that data file.
+  //
+  // The 'component' and 'standalone' data sources need this method to be called
+  // in order to locate the CLD data on disk.
+  // 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);
+
+  // 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();
+
+  // Sets the data source for 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.
+  static void Set(CldDataSource* data_source, bool overwrite);
+
+  // Returns the data source for this process. Guaranteed to never be null.
+  // If no instance has been set, this returns the same object obtained by
+  // calling NONE().
+  static CldDataSource* Get();
+
+  // Fetch the global instance of the "NONE" data source, i.e. a data source
+  // that gracefully does nothing. Callers should set this data source if it is
+  // the intent that there truly be no source of CLD data; this will result in
+  // language detection (and subsequently, translation) being unavailable.
+  // This is provided for convenience, to avoid a bunch of trivial subclasses
+  // whose only differences are in their unique combination of read-only values.
+  static CldDataSource* NONE();
+
+  // Fetch the global instance of the "static" data source.
+  // This is provided for convenience, to avoid a bunch of trivial subclasses
+  // whose only differences are in their unique combination of read-only values.
+  static CldDataSource* STATIC();
+
+  // Fetch the global instance of the "standalone" data source.
+  // This is provided for convenience, to avoid a bunch of trivial subclasses
+  // whose only differences are in their unique combination of read-only values.
+  static CldDataSource* STANDALONE();
+
+  // Fetch the global instance of the "component" data source.
+  // This is provided for convenience, to avoid a bunch of trivial subclasses
+  // whose only differences are in their unique combination of read-only values.
+  static CldDataSource* COMPONENT();
+
+ protected:
+  const std::string m_name;
+  const bool m_register_for_component_updates;
+  const bool m_use_standalone_data_file;
+  base::FilePath m_cached_filepath;  // Guarded by m_file_lock
+  base::Lock m_file_lock; // Guards m_cached_filepath
+
 };
 
 }  // namespace translate
 #endif  // COMPONENTS_TRANSLATE_CONTENT_COMMON_CLD_DATA_SOURCE_H_