tools/gn/loader.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef TOOLS_GN_LOADER_H_
   6 #define TOOLS_GN_LOADER_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "tools/gn/label.h"
  14 #include "tools/gn/scope.h"
  15
  16 namespace base {
  17 class MessageLoop;
  18 }
  19
  20 class BuildSettings;
  21 class LocationRange;
  22 class Settings;
  23 class SourceFile;
  24 class Toolchain;
  25
  26 // The loader manages execution of the different build files. It receives
  27 // requests (normally from the Builder) when new references are found, and also
  28 // manages loading the build config files.
  29 //
  30 // This loader class is abstract so it can be mocked out for testing the
  31 // Builder.
  32 class Loader : public base::RefCountedThreadSafe<Loader> {
  33  public:
  34   Loader();
  35
  36   // Loads the given file in the conext of the given toolchain. The initial
  37   // call to this (the one that actually starts the generation) should have an
  38   // empty toolchain name, which will trigger the load of the default build
  39   // config.
  40   virtual void Load(const SourceFile& file,
  41                     const LocationRange& origin,
  42                     const Label& toolchain_name) = 0;
  43
  44   // Notification that the given toolchain has loaded. This will unblock files
  45   // waiting on this definition.
  46   virtual void ToolchainLoaded(const Toolchain* toolchain) = 0;
  47
  48   // Returns the label of the default toolchain.
  49   virtual Label GetDefaultToolchain() const = 0;
  50
  51   // Returns information about the toolchain with the given label. Will return
  52   // false if we haven't processed this toolchain yet.
  53   virtual const Settings* GetToolchainSettings(const Label& label) const = 0;
  54
  55   // Helper function that extracts the file and toolchain name from the given
  56   // label, and calls Load().
  57   void Load(const Label& label, const LocationRange& origin);
  58
  59   // Returns the build file that the given label references.
  60   static SourceFile BuildFileForLabel(const Label& label);
  61
  62   // When processing the default build config, we want to capture the argument
  63   // of set_default_build_config. The implementation of that function uses this
  64   // constant as a property key to get the Label* out of the scope where the
  65   // label should be stored.
  66   static const void* kDefaultToolchainKey;
  67
  68  protected:
  69   friend class base::RefCountedThreadSafe<Loader>;
  70   virtual ~Loader();
  71 };
  72
  73 class LoaderImpl : public Loader {
  74  public:
  75   // Callback to emulate InputFileManager::AsyncLoadFile.
  76   typedef base::Callback<bool(const LocationRange&,
  77                               const BuildSettings*,
  78                               const SourceFile&,
  79                               const base::Callback<void(const ParseNode*)>&,
  80                               Err*)> AsyncLoadFileCallback;
  81
  82   LoaderImpl(const BuildSettings* build_settings);
  83
  84   // Loader implementation.
  85   virtual void Load(const SourceFile& file,
  86                     const LocationRange& origin,
  87                     const Label& toolchain_name) OVERRIDE;
  88   virtual void ToolchainLoaded(const Toolchain* toolchain) OVERRIDE;
  89   virtual Label GetDefaultToolchain() const OVERRIDE;
  90   virtual const Settings* GetToolchainSettings(
  91       const Label& label) const OVERRIDE;
  92
  93   // Sets the message loop corresponding to the main thread. By default this
  94   // class will use the thread active during construction, but there is not
  95   // a message loop active during construction all the time.
  96   void set_main_loop(base::MessageLoop* loop) { main_loop_ = loop; }
  97
  98   // The complete callback is called whenever there are no more pending loads.
  99   // Called on the main thread only. This may be called more than once if the
 100   // queue is drained, but then more stuff gets added.
 101   void set_complete_callback(const base::Closure& cb) {
 102     complete_callback_ = cb;
 103   }
 104
 105   // This callback is used when the loader finds it wants to load a file.
 106   void set_async_load_file(const AsyncLoadFileCallback& cb) {
 107     async_load_file_ = cb;
 108   }
 109
 110   const Label& default_toolchain_label() const {
 111     return default_toolchain_label_;
 112   }
 113
 114  private:
 115   struct LoadID;
 116   struct ToolchainRecord;
 117
 118   virtual ~LoaderImpl();
 119
 120   // Schedules the input file manager to load the given file.
 121   void ScheduleLoadFile(const Settings* settings,
 122                         const LocationRange& origin,
 123                         const SourceFile& file);
 124   void ScheduleLoadBuildConfig(
 125       Settings* settings,
 126       const Scope::KeyValueMap& toolchain_overrides);
 127
 128   // Runs the given file on the background thread. These are called by the
 129   // input file manager.
 130   void BackgroundLoadFile(const Settings* settings,
 131                           const SourceFile& file_name,
 132                           const ParseNode* root);
 133   void BackgroundLoadBuildConfig(
 134       Settings* settings,
 135       const Scope::KeyValueMap& toolchain_overrides,
 136       const ParseNode* root);
 137
 138   // Posted to the main thread when any file other than a build config file
 139   // file has completed running.
 140   void DidLoadFile();
 141
 142   // Posted to the main thread when any build config file has completed
 143   // running. The label should be the name of the toolchain.
 144   //
 145   // If there is no defauled toolchain loaded yet, we'll assume that the first
 146   // call to this indicates to the default toolchain, and this function will
 147   // set the default toolchain name to the given label.
 148   void DidLoadBuildConfig(const Label& label);
 149
 150   // Decrements the pending_loads_ variable and issues the complete callback if
 151   // necessary.
 152   void DecrementPendingLoads();
 153
 154   // Forwards to the appropriate location to load the file.
 155   bool AsyncLoadFile(const LocationRange& origin,
 156                      const BuildSettings* build_settings,
 157                      const SourceFile& file_name,
 158                      const base::Callback<void(const ParseNode*)>& callback,
 159                      Err* err);
 160
 161   base::MessageLoop* main_loop_;
 162
 163   int pending_loads_;
 164   base::Closure complete_callback_;
 165
 166   // When non-null, use this callback instead of the InputFileManager for
 167   // mocking purposes.
 168   AsyncLoadFileCallback async_load_file_;
 169
 170   typedef std::set<LoadID> LoadIDSet;
 171   LoadIDSet invocations_;
 172
 173   const BuildSettings* build_settings_;
 174   Label default_toolchain_label_;
 175
 176   // Records for the build config file loads.
 177   // Owning pointers.
 178   typedef std::map<Label, ToolchainRecord*> ToolchainRecordMap;
 179   ToolchainRecordMap toolchain_records_;
 180 };
 181
 182 #endif  // TOOLS_GN_LOADER_H_