Add support for saving the current configuration settings (#535)

Add support for saving the current configuration settings as a named
configuration and reloading such a configuration later.

All of the configurations are stored in a settings file, by default:
~/.config/pprof.json

A struct named config replaces the old map[string]string which used
to store the set of configurable options. Instead, each option is
now a field in the config struct.

The UI now has a new 'Config' menu with

Save as: prompts for a name and saves current config.
Default: applies default config.
$X: for every config named X: applies settings from X.

The currently selected config is highlighted.

Every named config has a delete button to control deletion.

Some semi-related changes:
1. Both filefunctions and functions in the granularity group had an
   initial value of true, which is incorrect since these are mutually
   incompatible choices. Set filefunctions' initial value to false.
2. Renamed the group for sorting from "cumulative" to "sort".
3. Store testing.T in TestUI instead of leaving the field nil.

doc/README.md

 
 * **-symbolize=demangle=templates:** Demangle, and trim function parameters, but
   not template parameters.
+
+# Web Interface
+
+When the user requests a web interface (by supplying an `-http=[host]:[port]`
+argument on the command-line), pprof starts a web server and opens a browser
+window pointing at that server. The web interface provided by the server allows
+the user to interactively view profile data in multiple formats.
+
+The top of the display is a header that contains some buttons and menus.
+
+## Config
+
+The `Config` menu allows the user to save the current refinement
+settings (e.g., the focus and hide list) as a named configuration. A
+saved configuration can later be re-applied to reinstitue the saved
+refinements. The `Config` menu contains:
+
+**Save as ...**: shows a dialog where the user can type in a
+configuration name. The current refinement settings are saved under
+the specified name.
+
+**Default**: switches back to the default view by removing all refinements.
+
+The `Config` menu also contains an entry per named
+configuration. Selecting such an entry applies that configuration. The
+currently selected entry is marked with a ✓. Clicking on the 🗙 on the
+right-hand side of such an entry deletes the configuration (after
+prompting the user to confirm).
+
+## TODO: cover the following issues:
+
+*   Overall layout
+*   Menu entries
+*   Explanation of all the views

internal/driver/cli.go

 	flagHTTP := flag.String("http", "", "Present interactive web UI at the specified http host:port")
 	flagNoBrowser := flag.Bool("no_browser", false, "Skip opening a browswer for the interactive web UI")
 
-	// Flags used during command processing
-	installedFlags := installFlags(flag)
+	// Flags that set configuration properties.
+	cfg := currentConfig()
+	configFlagSetter := installConfigFlags(flag, &cfg)
 
 	flagCommands := make(map[string]*bool)
 	flagParamCommands := make(map[string]*string)
 		}
 	}
 
-	// Report conflicting options
-	if err := updateFlags(installedFlags); err != nil {
+	// Apply any specified flags to cfg.
+	if err := configFlagSetter(); err != nil {
 		return nil, nil, err
 	}
 
 		return nil, nil, errors.New("-no_browser only makes sense with -http")
 	}
 
-	si := pprofVariables["sample_index"].value
+	si := cfg.SampleIndex
 	si = sampleIndex(flagTotalDelay, si, "delay", "-total_delay", o.UI)
 	si = sampleIndex(flagMeanDelay, si, "delay", "-mean_delay", o.UI)
 	si = sampleIndex(flagContentions, si, "contentions", "-contentions", o.UI)
 	si = sampleIndex(flagInUseObjects, si, "inuse_objects", "-inuse_objects", o.UI)
 	si = sampleIndex(flagAllocSpace, si, "alloc_space", "-alloc_space", o.UI)
 	si = sampleIndex(flagAllocObjects, si, "alloc_objects", "-alloc_objects", o.UI)
-	pprofVariables.set("sample_index", si)
+	cfg.SampleIndex = si
 
 	if *flagMeanDelay {
-		pprofVariables.set("mean", "true")
+		cfg.Mean = true
 	}
 
 	source := &source{
 		return nil, nil, err
 	}
 
-	normalize := pprofVariables["normalize"].boolValue()
+	normalize := cfg.Normalize
 	if normalize && len(source.Base) == 0 {
 		return nil, nil, errors.New("must have base profile to normalize by")
 	}
 	if bu, ok := o.Obj.(*binutils.Binutils); ok {
 		bu.SetTools(*flagTools)
 	}
+
+	setCurrentConfig(cfg)
 	return source, cmd, nil
 }
 
 	return l
 }
 
-// installFlags creates command line flags for pprof variables.
-func installFlags(flag plugin.FlagSet) flagsInstalled {
-	f := flagsInstalled{
-		ints:    make(map[string]*int),
-		bools:   make(map[string]*bool),
-		floats:  make(map[string]*float64),
-		strings: make(map[string]*string),
-	}
-	for n, v := range pprofVariables {
-		switch v.kind {
-		case boolKind:
-			if v.group != "" {
-				// Set all radio variables to false to identify conflicts.
-				f.bools[n] = flag.Bool(n, false, v.help)
+// installConfigFlags creates command line flags for configuration
+// fields and returns a function which can be called after flags have
+// been parsed to copy any flags specified on the command line to
+// *cfg.
+func installConfigFlags(flag plugin.FlagSet, cfg *config) func() error {
+	// List of functions for setting the different parts of a config.
+	var setters []func()
+	var err error // Holds any errors encountered while running setters.
+
+	for _, field := range configFields {
+		n := field.name
+		help := configHelp[n]
+		var setter func()
+		switch ptr := cfg.fieldPtr(field).(type) {
+		case *bool:
+			f := flag.Bool(n, *ptr, help)
+			setter = func() { *ptr = *f }
+		case *int:
+			f := flag.Int(n, *ptr, help)
+			setter = func() { *ptr = *f }
+		case *float64:
+			f := flag.Float64(n, *ptr, help)
+			setter = func() { *ptr = *f }
+		case *string:
+			if len(field.choices) == 0 {
+				f := flag.String(n, *ptr, help)
+				setter = func() { *ptr = *f }
 			} else {
-				f.bools[n] = flag.Bool(n, v.boolValue(), v.help)
+				// Make a separate flag per possible choice.
+				// Set all flags to initially false so we can
+				// identify conflicts.
+				bools := make(map[string]*bool)
+				for _, choice := range field.choices {
+					bools[choice] = flag.Bool(choice, false, configHelp[choice])
+				}
+				setter = func() {
+					var set []string
+					for k, v := range bools {
+						if *v {
+							set = append(set, k)
+						}
+					}
+					switch len(set) {
+					case 0:
+						// Leave as default value.
+					case 1:
+						*ptr = set[0]
+					default:
+						err = fmt.Errorf("conflicting options set: %v", set)
+					}
+				}
 			}
-		case intKind:
-			f.ints[n] = flag.Int(n, v.intValue(), v.help)
-		case floatKind:
-			f.floats[n] = flag.Float64(n, v.floatValue(), v.help)
-		case stringKind:
-			f.strings[n] = flag.String(n, v.value, v.help)
 		}
+		setters = append(setters, setter)
 	}
-	return f
-}
 
-// updateFlags updates the pprof variables according to the flags
-// parsed in the command line.
-func updateFlags(f flagsInstalled) error {
-	vars := pprofVariables
-	groups := map[string]string{}
-	for n, v := range f.bools {
-		vars.set(n, fmt.Sprint(*v))
-		if *v {
-			g := vars[n].group
-			if g != "" && groups[g] != "" {
-				return fmt.Errorf("conflicting options %q and %q set", n, groups[g])
+	return func() error {
+		// Apply the setter for every flag.
+		for _, setter := range setters {
+			setter()
+			if err != nil {
+				return err
 			}
-			groups[g] = n
 		}
+		return nil
 	}
-	for n, v := range f.ints {
-		vars.set(n, fmt.Sprint(*v))
-	}
-	for n, v := range f.floats {
-		vars.set(n, fmt.Sprint(*v))
-	}
-	for n, v := range f.strings {
-		vars.set(n, *v)
-	}
-	return nil
-}
-
-type flagsInstalled struct {
-	ints    map[string]*int
-	bools   map[string]*bool
-	floats  map[string]*float64
-	strings map[string]*string
 }
 
 // isBuildID determines if the profile may contain a build ID, by

internal/driver/commands.go

 	"os/exec"
 	"runtime"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 
 // SetVariableDefault sets the default value for a pprof
 // variable. This enables extensions to set their own defaults.
 func SetVariableDefault(variable, value string) {
-	if v := pprofVariables[variable]; v != nil {
-		v.value = value
-	}
+	configure(variable, value)
 }
 
 // PostProcessor is a function that applies post-processing to the report output
 	"weblist": {report.WebList, nil, invokeVisualizer("html", browsers()), true, "Display annotated source in a web browser", listHelp("weblist", false)},
 }
 
-// pprofVariables are the configuration parameters that affect the
-// reported generated by pprof.
-var pprofVariables = variables{
+// configHelp contains help text per configuration parameter.
+var configHelp = map[string]string{
 	// Filename for file-based output formats, stdout by default.
-	"output": &variable{stringKind, "", "", helpText("Output filename for file-based outputs")},
+	"output": helpText("Output filename for file-based outputs"),
 
 	// Comparisons.
-	"drop_negative": &variable{boolKind, "f", "", helpText(
+	"drop_negative": helpText(
 		"Ignore negative differences",
-		"Do not show any locations with values <0.")},
+		"Do not show any locations with values <0."),
 
 	// Graph handling options.
-	"call_tree": &variable{boolKind, "f", "", helpText(
+	"call_tree": helpText(
 		"Create a context-sensitive call tree",
-		"Treat locations reached through different paths as separate.")},
+		"Treat locations reached through different paths as separate."),
 
 	// Display options.
-	"relative_percentages": &variable{boolKind, "f", "", helpText(
+	"relative_percentages": helpText(
 		"Show percentages relative to focused subgraph",
 		"If unset, percentages are relative to full graph before focusing",
-		"to facilitate comparison with original graph.")},
-	"unit": &variable{stringKind, "minimum", "", helpText(
+		"to facilitate comparison with original graph."),
+	"unit": helpText(
 		"Measurement units to display",
 		"Scale the sample values to this unit.",
 		"For time-based profiles, use seconds, milliseconds, nanoseconds, etc.",
 		"For memory profiles, use megabytes, kilobytes, bytes, etc.",
-		"Using auto will scale each value independently to the most natural unit.")},
-	"compact_labels": &variable{boolKind, "f", "", "Show minimal headers"},
-	"source_path":    &variable{stringKind, "", "", "Search path for source files"},
-	"trim_path":      &variable{stringKind, "", "", "Path to trim from source paths before search"},
-	"intel_syntax": &variable{boolKind, "f", "", helpText(
+		"Using auto will scale each value independently to the most natural unit."),
+	"compact_labels": "Show minimal headers",
+	"source_path":    "Search path for source files",
+	"trim_path":      "Path to trim from source paths before search",
+	"intel_syntax": helpText(
 		"Show assembly in Intel syntax",
-		"Only applicable to commands `disasm` and `weblist`")},
+		"Only applicable to commands `disasm` and `weblist`"),
 
 	// Filtering options
-	"nodecount": &variable{intKind, "-1", "", helpText(
+	"nodecount": helpText(
 		"Max number of nodes to show",
 		"Uses heuristics to limit the number of locations to be displayed.",
-		"On graphs, dotted edges represent paths through nodes that have been removed.")},
-	"nodefraction": &variable{floatKind, "0.005", "", "Hide nodes below <f>*total"},
-	"edgefraction": &variable{floatKind, "0.001", "", "Hide edges below <f>*total"},
-	"trim": &variable{boolKind, "t", "", helpText(
+		"On graphs, dotted edges represent paths through nodes that have been removed."),
+	"nodefraction": "Hide nodes below <f>*total",
+	"edgefraction": "Hide edges below <f>*total",
+	"trim": helpText(
 		"Honor nodefraction/edgefraction/nodecount defaults",
-		"Set to false to get the full profile, without any trimming.")},
-	"focus": &variable{stringKind, "", "", helpText(
+		"Set to false to get the full profile, without any trimming."),
+	"focus": helpText(
 		"Restricts to samples going through a node matching regexp",
 		"Discard samples that do not include a node matching this regexp.",
-		"Matching includes the function name, filename or object name.")},
-	"ignore": &variable{stringKind, "", "", helpText(
+		"Matching includes the function name, filename or object name."),
+	"ignore": helpText(
 		"Skips paths going through any nodes matching regexp",
 		"If set, discard samples that include a node matching this regexp.",
-		"Matching includes the function name, filename or object name.")},
-	"prune_from": &variable{stringKind, "", "", helpText(
+		"Matching includes the function name, filename or object name."),
+	"prune_from": helpText(
 		"Drops any functions below the matched frame.",
 		"If set, any frames matching the specified regexp and any frames",
-		"below it will be dropped from each sample.")},
-	"hide": &variable{stringKind, "", "", helpText(
+		"below it will be dropped from each sample."),
+	"hide": helpText(
 		"Skips nodes matching regexp",
 		"Discard nodes that match this location.",
 		"Other nodes from samples that include this location will be shown.",
-		"Matching includes the function name, filename or object name.")},
-	"show": &variable{stringKind, "", "", helpText(
+		"Matching includes the function name, filename or object name."),
+	"show": helpText(
 		"Only show nodes matching regexp",
 		"If set, only show nodes that match this location.",
-		"Matching includes the function name, filename or object name.")},
-	"show_from": &variable{stringKind, "", "", helpText(
+		"Matching includes the function name, filename or object name."),
+	"show_from": helpText(
 		"Drops functions above the highest matched frame.",
 		"If set, all frames above the highest match are dropped from every sample.",
-		"Matching includes the function name, filename or object name.")},
-	"tagfocus": &variable{stringKind, "", "", helpText(
+		"Matching includes the function name, filename or object name."),
+	"tagfocus": helpText(
 		"Restricts to samples with tags in range or matched by regexp",
 		"Use name=value syntax to limit the matching to a specific tag.",
 		"Numeric tag filter examples: 1kb, 1kb:10kb, memory=32mb:",
-		"String tag filter examples: foo, foo.*bar, mytag=foo.*bar")},
-	"tagignore": &variable{stringKind, "", "", helpText(
+		"String tag filter examples: foo, foo.*bar, mytag=foo.*bar"),
+	"tagignore": helpText(
 		"Discard samples with tags in range or matched by regexp",
 		"Use name=value syntax to limit the matching to a specific tag.",
 		"Numeric tag filter examples: 1kb, 1kb:10kb, memory=32mb:",
-		"String tag filter examples: foo, foo.*bar, mytag=foo.*bar")},
-	"tagshow": &variable{stringKind, "", "", helpText(
+		"String tag filter examples: foo, foo.*bar, mytag=foo.*bar"),
+	"tagshow": helpText(
 		"Only consider tags matching this regexp",
-		"Discard tags that do not match this regexp")},
-	"taghide": &variable{stringKind, "", "", helpText(
+		"Discard tags that do not match this regexp"),
+	"taghide": helpText(
 		"Skip tags matching this regexp",
-		"Discard tags that match this regexp")},
+		"Discard tags that match this regexp"),
 	// Heap profile options
-	"divide_by": &variable{floatKind, "1", "", helpText(
+	"divide_by": helpText(
 		"Ratio to divide all samples before visualization",
-		"Divide all samples values by a constant, eg the number of processors or jobs.")},
-	"mean": &variable{boolKind, "f", "", helpText(
+		"Divide all samples values by a constant, eg the number of processors or jobs."),
+	"mean": helpText(
 		"Average sample value over first value (count)",
 		"For memory profiles, report average memory per allocation.",
-		"For time-based profiles, report average time per event.")},
-	"sample_index": &variable{stringKind, "", "", helpText(
+		"For time-based profiles, report average time per event."),
+	"sample_index": helpText(
 		"Sample value to report (0-based index or name)",
 		"Profiles contain multiple values per sample.",
-		"Use sample_index=i to select the ith value (starting at 0).")},
-	"normalize": &variable{boolKind, "f", "", helpText(
-		"Scales profile based on the base profile.")},
+		"Use sample_index=i to select the ith value (starting at 0)."),
+	"normalize": helpText(
+		"Scales profile based on the base profile."),
 
 	// Data sorting criteria
-	"flat": &variable{boolKind, "t", "cumulative", helpText("Sort entries based on own weight")},
-	"cum":  &variable{boolKind, "f", "cumulative", helpText("Sort entries based on cumulative weight")},
+	"flat": helpText("Sort entries based on own weight"),
+	"cum":  helpText("Sort entries based on cumulative weight"),
 
 	// Output granularity
-	"functions": &variable{boolKind, "t", "granularity", helpText(
+	"functions": helpText(
 		"Aggregate at the function level.",
-		"Ignores the filename where the function was defined.")},
-	"filefunctions": &variable{boolKind, "t", "granularity", helpText(
+		"Ignores the filename where the function was defined."),
+	"filefunctions": helpText(
 		"Aggregate at the function level.",
-		"Takes into account the filename where the function was defined.")},
-	"files": &variable{boolKind, "f", "granularity", "Aggregate at the file level."},
-	"lines": &variable{boolKind, "f", "granularity", "Aggregate at the source code line level."},
-	"addresses": &variable{boolKind, "f", "granularity", helpText(
+		"Takes into account the filename where the function was defined."),
+	"files": "Aggregate at the file level.",
+	"lines": "Aggregate at the source code line level.",
+	"addresses": helpText(
 		"Aggregate at the address level.",
-		"Includes functions' addresses in the output.")},
-	"noinlines": &variable{boolKind, "f", "", helpText(
+		"Includes functions' addresses in the output."),
+	"noinlines": helpText(
 		"Ignore inlines.",
-		"Attributes inlined functions to their first out-of-line caller.")},
+		"Attributes inlined functions to their first out-of-line caller."),
 }
 
 func helpText(s ...string) string {
 	return strings.Join(s, "\n") + "\n"
 }
 
-// usage returns a string describing the pprof commands and variables.
-// if commandLine is set, the output reflect cli usage.
+// usage returns a string describing the pprof commands and configuration
+// options.  if commandLine is set, the output reflect cli usage.
 func usage(commandLine bool) string {
 	var prefix string
 	if commandLine {
 	help = help + strings.Join(commands, "\n") + "\n\n" +
 		"  Options:\n"
 
-	// Print help for variables after sorting them.
-	// Collect radio variables by their group name to print them together.
-	radioOptions := make(map[string][]string)
+	// Print help for configuration options after sorting them.
+	// Collect choices for multi-choice options print them together.
 	var variables []string
-	for name, vr := range pprofVariables {
-		if vr.group != "" {
-			radioOptions[vr.group] = append(radioOptions[vr.group], name)
+	var radioStrings []string
+	for _, f := range configFields {
+		if len(f.choices) == 0 {
+			variables = append(variables, fmtHelp(prefix+f.name, configHelp[f.name]))
 			continue
 		}
-		variables = append(variables, fmtHelp(prefix+name, vr.help))
-	}
-	sort.Strings(variables)
-
-	help = help + strings.Join(variables, "\n") + "\n\n" +
-		"  Option groups (only set one per group):\n"
-
-	var radioStrings []string
-	for radio, ops := range radioOptions {
-		sort.Strings(ops)
-		s := []string{fmtHelp(radio, "")}
-		for _, op := range ops {
-			s = append(s, "  "+fmtHelp(prefix+op, pprofVariables[op].help))
+		// Format help for for this group.
+		s := []string{fmtHelp(f.name, "")}
+		for _, choice := range f.choices {
+			s = append(s, "  "+fmtHelp(prefix+choice, configHelp[choice]))
 		}
-
 		radioStrings = append(radioStrings, strings.Join(s, "\n"))
 	}
+	sort.Strings(variables)
 	sort.Strings(radioStrings)
-	return help + strings.Join(radioStrings, "\n")
+	return help + strings.Join(variables, "\n") + "\n\n" +
+		"  Option groups (only set one per group):\n" +
+		strings.Join(radioStrings, "\n")
 }
 
 func reportHelp(c string, cum, redirect bool) string {
 	}
 }
 
-// variables describe the configuration parameters recognized by pprof.
-type variables map[string]*variable
-
-// variable is a single configuration parameter.
-type variable struct {
-	kind  int    // How to interpret the value, must be one of the enums below.
-	value string // Effective value. Only values appropriate for the Kind should be set.
-	group string // boolKind variables with the same Group != "" cannot be set simultaneously.
-	help  string // Text describing the variable, in multiple lines separated by newline.
-}
-
-const (
-	// variable.kind must be one of these variables.
-	boolKind = iota
-	intKind
-	floatKind
-	stringKind
-)
-
-// set updates the value of a variable, checking that the value is
-// suitable for the variable Kind.
-func (vars variables) set(name, value string) error {
-	v := vars[name]
-	if v == nil {
-		return fmt.Errorf("no variable %s", name)
-	}
-	var err error
-	switch v.kind {
-	case boolKind:
-		var b bool
-		if b, err = stringToBool(value); err == nil {
-			if v.group != "" && !b {
-				err = fmt.Errorf("%q can only be set to true", name)
-			}
-		}
-	case intKind:
-		_, err = strconv.Atoi(value)
-	case floatKind:
-		_, err = strconv.ParseFloat(value, 64)
-	case stringKind:
-		// Remove quotes, particularly useful for empty values.
-		if len(value) > 1 && strings.HasPrefix(value, `"`) && strings.HasSuffix(value, `"`) {
-			value = value[1 : len(value)-1]
-		}
-	}
-	if err != nil {
-		return err
-	}
-	vars[name].value = value
-	if group := vars[name].group; group != "" {
-		for vname, vvar := range vars {
-			if vvar.group == group && vname != name {
-				vvar.value = "f"
-			}
-		}
-	}
-	return err
-}
-
-// boolValue returns the value of a boolean variable.
-func (v *variable) boolValue() bool {
-	b, err := stringToBool(v.value)
-	if err != nil {
-		panic("unexpected value " + v.value + " for bool ")
-	}
-	return b
-}
-
-// intValue returns the value of an intKind variable.
-func (v *variable) intValue() int {
-	i, err := strconv.Atoi(v.value)
-	if err != nil {
-		panic("unexpected value " + v.value + " for int ")
-	}
-	return i
-}
-
-// floatValue returns the value of a Float variable.
-func (v *variable) floatValue() float64 {
-	f, err := strconv.ParseFloat(v.value, 64)
-	if err != nil {
-		panic("unexpected value " + v.value + " for float ")
-	}
-	return f
-}
-
-// stringValue returns a canonical representation for a variable.
-func (v *variable) stringValue() string {
-	switch v.kind {
-	case boolKind:
-		return fmt.Sprint(v.boolValue())
-	case intKind:
-		return fmt.Sprint(v.intValue())
-	case floatKind:
-		return fmt.Sprint(v.floatValue())
-	}
-	return v.value
-}
-
+// stringToBool is a custom parser for bools. We avoid using strconv.ParseBool
+// to remain compatible with old pprof behavior (e.g., treating "" as true).
 func stringToBool(s string) (bool, error) {
 	switch strings.ToLower(s) {
 	case "true", "t", "yes", "y", "1", "":
 		return false, fmt.Errorf(`illegal value "%s" for bool variable`, s)
 	}
 }
-
-// makeCopy returns a duplicate of a set of shell variables.
-func (vars variables) makeCopy() variables {
-	varscopy := make(variables, len(vars))
-	for n, v := range vars {
-		vcopy := *v
-		varscopy[n] = &vcopy
-	}
-	return varscopy
-}

internal/driver/config.go

+package driver
+
+import (
+	"fmt"
+	"net/url"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// config holds settings for a single named config.
+// The JSON tag name for a field is used both for JSON encoding and as
+// a named variable.
+type config struct {
+	// Filename for file-based output formats, stdout by default.
+	Output string `json:"-"`
+
+	// Display options.
+	CallTree            bool    `json:"call_tree,omitempty"`
+	RelativePercentages bool    `json:"relative_percentages,omitempty"`
+	Unit                string  `json:"unit,omitempty"`
+	CompactLabels       bool    `json:"compact_labels,omitempty"`
+	SourcePath          string  `json:"-"`
+	TrimPath            string  `json:"-"`
+	IntelSyntax         bool    `json:"intel_syntax,omitempty"`
+	Mean                bool    `json:"mean,omitempty"`
+	SampleIndex         string  `json:"-"`
+	DivideBy            float64 `json:"-"`
+	Normalize           bool    `json:"normalize,omitempty"`
+	Sort                string  `json:"sort,omitempty"`
+
+	// Filtering options
+	DropNegative bool    `json:"drop_negative,omitempty"`
+	NodeCount    int     `json:"nodecount,omitempty"`
+	NodeFraction float64 `json:"nodefraction,omitempty"`
+	EdgeFraction float64 `json:"edgefraction,omitempty"`
+	Trim         bool    `json:"trim,omitempty"`
+	Focus        string  `json:"focus,omitempty"`
+	Ignore       string  `json:"ignore,omitempty"`
+	PruneFrom    string  `json:"prune_from,omitempty"`
+	Hide         string  `json:"hide,omitempty"`
+	Show         string  `json:"show,omitempty"`
+	ShowFrom     string  `json:"show_from,omitempty"`
+	TagFocus     string  `json:"tagfocus,omitempty"`
+	TagIgnore    string  `json:"tagignore,omitempty"`
+	TagShow      string  `json:"tagshow,omitempty"`
+	TagHide      string  `json:"taghide,omitempty"`
+	NoInlines    bool    `json:"noinlines,omitempty"`
+
+	// Output granularity
+	Granularity string `json:"granularity,omitempty"`
+}
+
+// defaultConfig returns the default configuration values; it is unaffected by
+// flags and interactive assignments.
+func defaultConfig() config {
+	return config{
+		Unit:         "minimum",
+		NodeCount:    -1,
+		NodeFraction: 0.005,
+		EdgeFraction: 0.001,
+		Trim:         true,
+		DivideBy:     1.0,
+		Sort:         "flat",
+		Granularity:  "functions",
+	}
+}
+
+// currentConfig holds the current configuration values; it is affected by
+// flags and interactive assignments.
+var currentCfg = defaultConfig()
+var currentMu sync.Mutex
+
+func currentConfig() config {
+	currentMu.Lock()
+	defer currentMu.Unlock()
+	return currentCfg
+}
+
+func setCurrentConfig(cfg config) {
+	currentMu.Lock()
+	defer currentMu.Unlock()
+	currentCfg = cfg
+}
+
+// configField contains metadata for a single configuration field.
+type configField struct {
+	name         string              // JSON field name/key in variables
+	urlparam     string              // URL parameter name
+	saved        bool                // Is field saved in settings?
+	field        reflect.StructField // Field in config
+	choices      []string            // Name Of variables in group
+	defaultValue string              // Default value for this field.
+}
+
+var (
+	configFields []configField // Precomputed metadata per config field
+
+	// configFieldMap holds an entry for every config field as well as an
+	// entry for every valid choice for a multi-choice field.
+	configFieldMap map[string]configField
+)
+
+func init() {
+	// Config names for fields that are not saved in settings and therefore
+	// do not have a JSON name.
+	notSaved := map[string]string{
+		// Not saved in settings, but present in URLs.
+		"SampleIndex": "sample_index",
+
+		// Following fields are also not placed in URLs.
+		"Output":     "output",
+		"SourcePath": "source_path",
+		"TrimPath":   "trim_path",
+		"DivideBy":   "divide_by",
+	}
+
+	// choices holds the list of allowed values for config fields that can
+	// take on one of a bounded set of values.
+	choices := map[string][]string{
+		"sort":        {"cum", "flat"},
+		"granularity": {"functions", "filefunctions", "files", "lines", "addresses"},
+	}
+
+	// urlparam holds the mapping from a config field name to the URL
+	// parameter used to hold that config field. If no entry is present for
+	// a name, the corresponding field is not saved in URLs.
+	urlparam := map[string]string{
+		"drop_negative":        "dropneg",
+		"call_tree":            "calltree",
+		"relative_percentages": "rel",
+		"unit":                 "unit",
+		"compact_labels":       "compact",
+		"intel_syntax":         "intel",
+		"nodecount":            "n",
+		"nodefraction":         "nf",
+		"edgefraction":         "ef",
+		"trim":                 "trim",
+		"focus":                "f",
+		"ignore":               "i",
+		"prune_from":           "prunefrom",
+		"hide":                 "h",
+		"show":                 "s",
+		"show_from":            "sf",
+		"tagfocus":             "tf",
+		"tagignore":            "ti",
+		"tagshow":              "ts",
+		"taghide":              "th",
+		"mean":                 "mean",
+		"sample_index":         "si",
+		"normalize":            "norm",
+		"sort":                 "sort",
+		"granularity":          "g",
+		"noinlines":            "noinlines",
+	}
+
+	def := defaultConfig()
+	configFieldMap = map[string]configField{}
+	t := reflect.TypeOf(config{})
+	for i, n := 0, t.NumField(); i < n; i++ {
+		field := t.Field(i)
+		js := strings.Split(field.Tag.Get("json"), ",")
+		if len(js) == 0 {
+			continue
+		}
+		// Get the configuration name for this field.
+		name := js[0]
+		if name == "-" {
+			name = notSaved[field.Name]
+			if name == "" {
+				// Not a configurable field.
+				continue
+			}
+		}
+		f := configField{
+			name:     name,
+			urlparam: urlparam[name],
+			saved:    (name == js[0]),
+			field:    field,
+			choices:  choices[name],
+		}
+		f.defaultValue = def.get(f)
+		configFields = append(configFields, f)
+		configFieldMap[f.name] = f
+		for _, choice := range f.choices {
+			configFieldMap[choice] = f
+		}
+	}
+}
+
+// fieldPtr returns a pointer to the field identified by f in *cfg.
+func (cfg *config) fieldPtr(f configField) interface{} {
+	// reflect.ValueOf: converts to reflect.Value
+	// Elem: dereferences cfg to make *cfg
+	// FieldByIndex: fetches the field
+	// Addr: takes address of field
+	// Interface: converts back from reflect.Value to a regular value
+	return reflect.ValueOf(cfg).Elem().FieldByIndex(f.field.Index).Addr().Interface()
+}
+
+// get returns the value of field f in cfg.
+func (cfg *config) get(f configField) string {
+	switch ptr := cfg.fieldPtr(f).(type) {
+	case *string:
+		return *ptr
+	case *int:
+		return fmt.Sprint(*ptr)
+	case *float64:
+		return fmt.Sprint(*ptr)
+	case *bool:
+		return fmt.Sprint(*ptr)
+	}
+	panic(fmt.Sprintf("unsupported config field type %v", f.field.Type))
+}
+
+// set sets the value of field f in cfg to value.
+func (cfg *config) set(f configField, value string) error {
+	switch ptr := cfg.fieldPtr(f).(type) {
+	case *string:
+		if len(f.choices) > 0 {
+			// Verify that value is one of the allowed choices.
+			for _, choice := range f.choices {
+				if choice == value {
+					*ptr = value
+					return nil
+				}
+			}
+			return fmt.Errorf("invalid %q value %q", f.name, value)
+		}
+		*ptr = value
+	case *int:
+		v, err := strconv.Atoi(value)
+		if err != nil {
+			return err
+		}
+		*ptr = v
+	case *float64:
+		v, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		*ptr = v
+	case *bool:
+		v, err := stringToBool(value)
+		if err != nil {
+			return err
+		}
+		*ptr = v
+	default:
+		panic(fmt.Sprintf("unsupported config field type %v", f.field.Type))
+	}
+	return nil
+}
+
+// isConfigurable returns true if name is either the name of a config field, or
+// a valid value for a multi-choice config field.
+func isConfigurable(name string) bool {
+	_, ok := configFieldMap[name]
+	return ok
+}
+
+// isBoolConfig returns true if name is either name of a boolean config field,
+// or a valid value for a multi-choice config field.
+func isBoolConfig(name string) bool {
+	f, ok := configFieldMap[name]
+	if !ok {
+		return false
+	}
+	if name != f.name {
+		return true // name must be one possible value for the field
+	}
+	var cfg config
+	_, ok = cfg.fieldPtr(f).(*bool)
+	return ok
+}
+
+// completeConfig returns the list of configurable names starting with prefix.
+func completeConfig(prefix string) []string {
+	var result []string
+	for v := range configFieldMap {
+		if strings.HasPrefix(v, prefix) {
+			result = append(result, v)
+		}
+	}
+	return result
+}
+
+// configure stores the name=value mapping into the current config, correctly
+// handling the case when name identifies a particular choice in a field.
+func configure(name, value string) error {
+	currentMu.Lock()
+	defer currentMu.Unlock()
+	f, ok := configFieldMap[name]
+	if !ok {
+		return fmt.Errorf("unknown config field %q", name)
+	}
+	if f.name == name {
+		return currentCfg.set(f, value)
+	}
+	// name must be one of the choices. If value is true, set field-value
+	// to name.
+	if v, err := strconv.ParseBool(value); v && err == nil {
+		return currentCfg.set(f, name)
+	}
+	return fmt.Errorf("unknown config field %q", name)
+}
+
+// resetTransient sets all transient fields in *cfg to their currently
+// configured values.
+func (cfg *config) resetTransient() {
+	current := currentConfig()
+	cfg.Output = current.Output
+	cfg.SourcePath = current.SourcePath
+	cfg.TrimPath = current.TrimPath
+	cfg.DivideBy = current.DivideBy
+	cfg.SampleIndex = current.SampleIndex
+}
+
+// applyURL updates *cfg based on params.
+func (cfg *config) applyURL(params url.Values) error {
+	for _, f := range configFields {
+		var value string
+		if f.urlparam != "" {
+			value = params.Get(f.urlparam)
+		}
+		if value == "" {
+			continue
+		}
+		if err := cfg.set(f, value); err != nil {
+			return fmt.Errorf("error setting config field %s: %v", f.name, err)
+		}
+	}
+	return nil
+}
+
+// makeURL returns a URL based on initialURL that contains the config contents
+// as parameters.  The second result is true iff a parameter value was changed.
+func (cfg *config) makeURL(initialURL url.URL) (url.URL, bool) {
+	q := initialURL.Query()
+	changed := false
+	for _, f := range configFields {
+		if f.urlparam == "" || !f.saved {
+			continue
+		}
+		v := cfg.get(f)
+		if v == f.defaultValue {
+			v = "" // URL for of default value is the empty string.
+		} else if f.field.Type.Kind() == reflect.Bool {
+			// Shorten bool values to "f" or "t"
+			v = v[:1]
+		}
+		if q.Get(f.urlparam) == v {
+			continue
+		}
+		changed = true
+		if v == "" {
+			q.Del(f.urlparam)
+		} else {
+			q.Set(f.urlparam, v)
+		}
+	}
+	if changed {
+		initialURL.RawQuery = q.Encode()
+	}
+	return initialURL, changed
+}

internal/driver/driver.go

 	}
 
 	if cmd != nil {
-		return generateReport(p, cmd, pprofVariables, o)
+		return generateReport(p, cmd, currentConfig(), o)
 	}
 
 	if src.HTTPHostport != "" {
 	return interactive(p, o)
 }
 
-func generateRawReport(p *profile.Profile, cmd []string, vars variables, o *plugin.Options) (*command, *report.Report, error) {
+func generateRawReport(p *profile.Profile, cmd []string, cfg config, o *plugin.Options) (*command, *report.Report, error) {
 	p = p.Copy() // Prevent modification to the incoming profile.
 
 	// Identify units of numeric tags in profile.
 		panic("unexpected nil command")
 	}
 
-	vars = applyCommandOverrides(cmd[0], c.format, vars)
+	cfg = applyCommandOverrides(cmd[0], c.format, cfg)
 
 	// Delay focus after configuring report to get percentages on all samples.
-	relative := vars["relative_percentages"].boolValue()
+	relative := cfg.RelativePercentages
 	if relative {
-		if err := applyFocus(p, numLabelUnits, vars, o.UI); err != nil {
+		if err := applyFocus(p, numLabelUnits, cfg, o.UI); err != nil {
 			return nil, nil, err
 		}
 	}
-	ropt, err := reportOptions(p, numLabelUnits, vars)
+	ropt, err := reportOptions(p, numLabelUnits, cfg)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	rpt := report.New(p, ropt)
 	if !relative {
-		if err := applyFocus(p, numLabelUnits, vars, o.UI); err != nil {
+		if err := applyFocus(p, numLabelUnits, cfg, o.UI); err != nil {
 			return nil, nil, err
 		}
 	}
-	if err := aggregate(p, vars); err != nil {
+	if err := aggregate(p, cfg); err != nil {
 		return nil, nil, err
 	}
 
 	return c, rpt, nil
 }
 
-func generateReport(p *profile.Profile, cmd []string, vars variables, o *plugin.Options) error {
-	c, rpt, err := generateRawReport(p, cmd, vars, o)
+func generateReport(p *profile.Profile, cmd []string, cfg config, o *plugin.Options) error {
+	c, rpt, err := generateRawReport(p, cmd, cfg, o)
 	if err != nil {
 		return err
 	}
 	}
 
 	// If no output is specified, use default visualizer.
-	output := vars["output"].value
+	output := cfg.Output
 	if output == "" {
 		if c.visualizer != nil {
 			return c.visualizer(src, os.Stdout, o.UI)
 	return out.Close()
 }
 
-func applyCommandOverrides(cmd string, outputFormat int, v variables) variables {
+func applyCommandOverrides(cmd string, outputFormat int, cfg config) config {
 	// Some report types override the trim flag to false below. This is to make
 	// sure the default heuristics of excluding insignificant nodes and edges
 	// from the call graph do not apply. One example where it is important is
 	// data is selected. So, with trimming enabled, the report could end up
 	// showing no data if the specified function is "uninteresting" as far as the
 	// trimming is concerned.
-	trim := v["trim"].boolValue()
+	trim := cfg.Trim
 
 	switch cmd {
 	case "disasm", "weblist":
 		trim = false
-		v.set("addresses", "t")
+		cfg.Granularity = "addresses"
 		// Force the 'noinlines' mode so that source locations for a given address
 		// collapse and there is only one for the given address. Without this
 		// cumulative metrics would be double-counted when annotating the assembly.
 		// This is because the merge is done by address and in case of an inlined
 		// stack each of the inlined entries is a separate callgraph node.
-		v.set("noinlines", "t")
+		cfg.NoInlines = true
 	case "peek":
 		trim = false
 	case "list":
 		trim = false
-		v.set("lines", "t")
+		cfg.Granularity = "lines"
 		// Do not force 'noinlines' to be false so that specifying
 		// "-list foo -noinlines" is supported and works as expected.
 	case "text", "top", "topproto":
-		if v["nodecount"].intValue() == -1 {
-			v.set("nodecount", "0")
+		if cfg.NodeCount == -1 {
+			cfg.NodeCount = 0
 		}
 	default:
-		if v["nodecount"].intValue() == -1 {
-			v.set("nodecount", "80")
+		if cfg.NodeCount == -1 {
+			cfg.NodeCount = 80
 		}
 	}
 
 	switch outputFormat {
 	case report.Proto, report.Raw, report.Callgrind:
 		trim = false
-		v.set("addresses", "t")
-		v.set("noinlines", "f")
+		cfg.Granularity = "addresses"
+		cfg.NoInlines = false
 	}
 
 	if !trim {
-		v.set("nodecount", "0")
-		v.set("nodefraction", "0")
-		v.set("edgefraction", "0")
+		cfg.NodeCount = 0
+		cfg.NodeFraction = 0
+		cfg.EdgeFraction = 0
 	}
-	return v
+	return cfg
 }
 
-func aggregate(prof *profile.Profile, v variables) error {
+func aggregate(prof *profile.Profile, cfg config) error {
 	var function, filename, linenumber, address bool
-	inlines := !v["noinlines"].boolValue()
-	switch {
-	case v["addresses"].boolValue():
+	inlines := !cfg.NoInlines
+	switch cfg.Granularity {
+	case "addresses":
 		if inlines {
 			return nil
 		}
 		filename = true
 		linenumber = true
 		address = true
-	case v["lines"].boolValue():
+	case "lines":
 		function = true
 		filename = true
 		linenumber = true
-	case v["files"].boolValue():
+	case "files":
 		filename = true
-	case v["functions"].boolValue():
+	case "functions":
 		function = true
-	case v["filefunctions"].boolValue():
+	case "filefunctions":
 		function = true
 		filename = true
 	default:
 	return prof.Aggregate(inlines, function, filename, linenumber, address)
 }
 
-func reportOptions(p *profile.Profile, numLabelUnits map[string]string, vars variables) (*report.Options, error) {
-	si, mean := vars["sample_index"].value, vars["mean"].boolValue()
+func reportOptions(p *profile.Profile, numLabelUnits map[string]string, cfg config) (*report.Options, error) {
+	si, mean := cfg.SampleIndex, cfg.Mean
 	value, meanDiv, sample, err := sampleFormat(p, si, mean)
 	if err != nil {
 		return nil, err
 		stype = "mean_" + stype
 	}
 
-	if vars["divide_by"].floatValue() == 0 {
+	if cfg.DivideBy == 0 {
 		return nil, fmt.Errorf("zero divisor specified")
 	}
 
 	var filters []string
-	for _, k := range []string{"focus", "ignore", "hide", "show", "show_from", "tagfocus", "tagignore", "tagshow", "taghide"} {
-		v := vars[k].value
+	addFilter := func(k string, v string) {
 		if v != "" {
 			filters = append(filters, k+"="+v)
 		}
 	}
+	addFilter("focus", cfg.Focus)
+	addFilter("ignore", cfg.Ignore)
+	addFilter("hide", cfg.Hide)
+	addFilter("show", cfg.Show)
+	addFilter("show_from", cfg.ShowFrom)
+	addFilter("tagfocus", cfg.TagFocus)
+	addFilter("tagignore", cfg.TagIgnore)
+	addFilter("tagshow", cfg.TagShow)
+	addFilter("taghide", cfg.TagHide)
 
 	ropt := &report.Options{
-		CumSort:      vars["cum"].boolValue(),
-		CallTree:     vars["call_tree"].boolValue(),
-		DropNegative: vars["drop_negative"].boolValue(),
+		CumSort:      cfg.Sort == "cum",
+		CallTree:     cfg.CallTree,
+		DropNegative: cfg.DropNegative,
 
-		CompactLabels: vars["compact_labels"].boolValue(),
-		Ratio:         1 / vars["divide_by"].floatValue(),
+		CompactLabels: cfg.CompactLabels,
+		Ratio:         1 / cfg.DivideBy,
 
-		NodeCount:    vars["nodecount"].intValue(),
-		NodeFraction: vars["nodefraction"].floatValue(),
-		EdgeFraction: vars["edgefraction"].floatValue(),
+		NodeCount:    cfg.NodeCount,
+		NodeFraction: cfg.NodeFraction,
+		EdgeFraction: cfg.EdgeFraction,
 
 		ActiveFilters: filters,
 		NumLabelUnits: numLabelUnits,
 		SampleType:        stype,
 		SampleUnit:        sample.Unit,
 
-		OutputUnit: vars["unit"].value,
+		OutputUnit: cfg.Unit,
 
-		SourcePath: vars["source_path"].stringValue(),
-		TrimPath:   vars["trim_path"].stringValue(),
+		SourcePath: cfg.SourcePath,
+		TrimPath:   cfg.TrimPath,
 
-		IntelSyntax: vars["intel_syntax"].boolValue(),
+		IntelSyntax: cfg.IntelSyntax,
 	}
 
 	if len(p.Mapping) > 0 && p.Mapping[0].File != "" {

internal/driver/driver_focus.go

 var tagFilterRangeRx = regexp.MustCompile("([+-]?[[:digit:]]+)([[:alpha:]]+)?")
 
 // applyFocus filters samples based on the focus/ignore options
-func applyFocus(prof *profile.Profile, numLabelUnits map[string]string, v variables, ui plugin.UI) error {
-	focus, err := compileRegexOption("focus", v["focus"].value, nil)
-	ignore, err := compileRegexOption("ignore", v["ignore"].value, err)
-	hide, err := compileRegexOption("hide", v["hide"].value, err)
-	show, err := compileRegexOption("show", v["show"].value, err)
-	showfrom, err := compileRegexOption("show_from", v["show_from"].value, err)
-	tagfocus, err := compileTagFilter("tagfocus", v["tagfocus"].value, numLabelUnits, ui, err)
-	tagignore, err := compileTagFilter("tagignore", v["tagignore"].value, numLabelUnits, ui, err)
-	prunefrom, err := compileRegexOption("prune_from", v["prune_from"].value, err)
+func applyFocus(prof *profile.Profile, numLabelUnits map[string]string, cfg config, ui plugin.UI) error {
+	focus, err := compileRegexOption("focus", cfg.Focus, nil)
+	ignore, err := compileRegexOption("ignore", cfg.Ignore, err)
+	hide, err := compileRegexOption("hide", cfg.Hide, err)
+	show, err := compileRegexOption("show", cfg.Show, err)
+	showfrom, err := compileRegexOption("show_from", cfg.ShowFrom, err)
+	tagfocus, err := compileTagFilter("tagfocus", cfg.TagFocus, numLabelUnits, ui, err)
+	tagignore, err := compileTagFilter("tagignore", cfg.TagIgnore, numLabelUnits, ui, err)
+	prunefrom, err := compileRegexOption("prune_from", cfg.PruneFrom, err)
 	if err != nil {
 		return err
 	}
 	warnNoMatches(tagfocus == nil || tfm, "TagFocus", ui)
 	warnNoMatches(tagignore == nil || tim, "TagIgnore", ui)
 
-	tagshow, err := compileRegexOption("tagshow", v["tagshow"].value, err)
-	taghide, err := compileRegexOption("taghide", v["taghide"].value, err)
+	tagshow, err := compileRegexOption("tagshow", cfg.TagShow, err)
+	taghide, err := compileRegexOption("taghide", cfg.TagHide, err)
 	tns, tnh := prof.FilterTagsByName(tagshow, taghide)
 	warnNoMatches(tagshow == nil || tns, "TagShow", ui)
 	warnNoMatches(tagignore == nil || tnh, "TagHide", ui)

internal/driver/driver_test.go

 		{"text", "long_name_funcs"},
 	}
 
-	baseVars := pprofVariables
-	defer func() { pprofVariables = baseVars }()
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
 	for _, tc := range testcase {
 		t.Run(tc.flags+":"+tc.source, func(t *testing.T) {
-			// Reset the pprof variables before processing
-			pprofVariables = baseVars.makeCopy()
+			// Reset config before processing
+			setCurrentConfig(baseConfig)
 
 			testUI := &proftest.TestUI{T: t, AllowRx: "Generating report in|Ignoring local file|expression matched no samples|Interpreted .* as range, not regexp"}
 
 			if err := PProf(o1); err != nil {
 				t.Fatalf("%s %q:  %v", tc.source, tc.flags, err)
 			}
-			// Reset the pprof variables after the proto invocation
-			pprofVariables = baseVars.makeCopy()
+			// Reset config after the proto invocation
+			setCurrentConfig(baseConfig)
 
 			// Read the profile from the encoded protobuf
 			outputTempFile, err := ioutil.TempFile("", "profile_output")
 	}
 }
 
+// TestOptionsHaveHelp tests that a help message is supplied for every
+// selectable option.
+func TestOptionsHaveHelp(t *testing.T) {
+	for _, f := range configFields {
+		// Check all choices if this is a group, else check f.name.
+		names := f.choices
+		if len(names) == 0 {
+			names = []string{f.name}
+		}
+		for _, name := range names {
+			if _, ok := configHelp[name]; !ok {
+				t.Errorf("missing help message for %q", name)
+			}
+		}
+	}
+}
+
 type testSymbolzMergeFetcher struct{}
 
 func (testSymbolzMergeFetcher) Fetch(s string, d, t time.Duration) (*profile.Profile, string, error) {
 }
 
 func TestSymbolzAfterMerge(t *testing.T) {
-	baseVars := pprofVariables
-	pprofVariables = baseVars.makeCopy()
-	defer func() { pprofVariables = baseVars }()
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
 
 	f := baseFlags()
 	f.args = []string{

internal/driver/fetch_test.go

 }
 
 func TestFetchWithBase(t *testing.T) {
-	baseVars := pprofVariables
-	defer func() { pprofVariables = baseVars }()
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
 
 	type WantSample struct {
 		values []int64
 
 	for _, tc := range testcases {
 		t.Run(tc.desc, func(t *testing.T) {
-			pprofVariables = baseVars.makeCopy()
+			setCurrentConfig(baseConfig)
 			f := testFlags{
 				stringLists: map[string][]string{
 					"base":      tc.bases,
 	os.Setenv(homeEnv(), tempdir)
 	defer os.Setenv(homeEnv(), saveHome)
 
-	baseVars := pprofVariables
-	pprofVariables = baseVars.makeCopy()
-	defer func() { pprofVariables = baseVars }()
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
 
 	tlsCert, _, _ := selfSignedCert(t, "")
 	tlsConfig := &tls.Config{Certificates: []tls.Certificate{tlsCert}}
 	os.Setenv(homeEnv(), tempdir)
 	defer os.Setenv(homeEnv(), saveHome)
 
-	baseVars := pprofVariables
-	pprofVariables = baseVars.makeCopy()
-	defer func() { pprofVariables = baseVars }()
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
 
 	cert, certBytes, keyBytes := selfSignedCert(t, "localhost")
 	cas := x509.NewCertPool()

internal/driver/flamegraph.go

 func (ui *webInterface) flamegraph(w http.ResponseWriter, req *http.Request) {
 	// Force the call tree so that the graph is a tree.
 	// Also do not trim the tree so that the flame graph contains all functions.
-	rpt, errList := ui.makeReport(w, req, []string{"svg"}, "call_tree", "true", "trim", "false")
+	rpt, errList := ui.makeReport(w, req, []string{"svg"}, func(cfg *config) {
+		cfg.CallTree = true
+		cfg.Trim = false
+	})
 	if rpt == nil {
 		return // error already reported
 	}
 		return
 	}
 
-	ui.render(w, "flamegraph", rpt, errList, config.Labels, webArgs{
+	ui.render(w, req, "flamegraph", rpt, errList, config.Labels, webArgs{
 		FlameGraph: template.JS(b),
 		Nodes:      nodeArr,
 	})

internal/driver/interactive.go

 func interactive(p *profile.Profile, o *plugin.Options) error {
 	// Enter command processing loop.
 	o.UI.SetAutoComplete(newCompleter(functionNames(p)))
-	pprofVariables.set("compact_labels", "true")
-	pprofVariables["sample_index"].help += fmt.Sprintf("Or use sample_index=name, with name in %v.\n", sampleTypes(p))
+	configure("compact_labels", "true")
+	configHelp["sample_index"] += fmt.Sprintf("Or use sample_index=name, with name in %v.\n", sampleTypes(p))
 
 	// Do not wait for the visualizer to complete, to allow multiple
 	// graphs to be visualized simultaneously.
 	interactiveMode = true
 	shortcuts := profileShortcuts(p)
 
-	// Get all groups in pprofVariables to allow for clearer error messages.
-	groups := groupOptions(pprofVariables)
-
 	greetings(p, o.UI)
 	for {
 		input, err := o.UI.ReadLine("(pprof) ")
 					}
 					value = strings.TrimSpace(value)
 				}
-				if v := pprofVariables[name]; v != nil {
+				if isConfigurable(name) {
 					// All non-bool options require inputs
-					if v.kind != boolKind && value == "" {
+					if len(s) == 1 && !isBoolConfig(name) {
 						o.UI.PrintErr(fmt.Errorf("please specify a value, e.g. %s=<val>", name))
 						continue
 					}
 							o.UI.PrintErr(err)
 							continue
 						}
+						if index < 0 || index >= len(p.SampleType) {
+							o.UI.PrintErr(fmt.Errorf("invalid sample_index %q", value))
+							continue
+						}
 						value = p.SampleType[index].Type
 					}
-					if err := pprofVariables.set(name, value); err != nil {
+					if err := configure(name, value); err != nil {
 						o.UI.PrintErr(err)
 					}
 					continue
 				}
-				// Allow group=variable syntax by converting into variable="".
-				if v := pprofVariables[value]; v != nil && v.group == name {
-					if err := pprofVariables.set(value, ""); err != nil {
-						o.UI.PrintErr(err)
-					}
-					continue
-				} else if okValues := groups[name]; okValues != nil {
-					o.UI.PrintErr(fmt.Errorf("unrecognized value for %s: %q. Use one of %s", name, value, strings.Join(okValues, ", ")))
-					continue
-				}
 			}
 
 			tokens := strings.Fields(input)
 				continue
 			}
 
-			args, vars, err := parseCommandLine(tokens)
+			args, cfg, err := parseCommandLine(tokens)
 			if err == nil {
-				err = generateReportWrapper(p, args, vars, o)
+				err = generateReportWrapper(p, args, cfg, o)
 			}
 
 			if err != nil {
 	}
 }
 
-// groupOptions returns a map containing all non-empty groups
-// mapped to an array of the option names in that group in
-// sorted order.
-func groupOptions(vars variables) map[string][]string {
-	groups := make(map[string][]string)
-	for name, option := range vars {
-		group := option.group
-		if group != "" {
-			groups[group] = append(groups[group], name)
-		}
-	}
-	for _, names := range groups {
-		sort.Strings(names)
-	}
-	return groups
-}
-
 var generateReportWrapper = generateReport // For testing purposes.
 
 // greetings prints a brief welcome and some overall profile
 // information before accepting interactive commands.
 func greetings(p *profile.Profile, ui plugin.UI) {
 	numLabelUnits := identifyNumLabelUnits(p, ui)
-	ropt, err := reportOptions(p, numLabelUnits, pprofVariables)
+	ropt, err := reportOptions(p, numLabelUnits, currentConfig())
 	if err == nil {
 		rpt := report.New(p, ropt)
 		ui.Print(strings.Join(report.ProfileLabels(rpt), "\n"))
 
 func printCurrentOptions(p *profile.Profile, ui plugin.UI) {
 	var args []string
-	type groupInfo struct {
-		set    string
-		values []string
-	}
-	groups := make(map[string]*groupInfo)
-	for n, o := range pprofVariables {
-		v := o.stringValue()
+	current := currentConfig()
+	for _, f := range configFields {
+		n := f.name
+		v := current.get(f)
 		comment := ""
-		if g := o.group; g != "" {
-			gi, ok := groups[g]
-			if !ok {
-				gi = &groupInfo{}
-				groups[g] = gi
-			}
-			if o.boolValue() {
-				gi.set = n
-			}
-			gi.values = append(gi.values, n)
-			continue
-		}
 		switch {
+		case len(f.choices) > 0:
+			values := append([]string{}, f.choices...)
+			sort.Strings(values)
+			comment = "[" + strings.Join(values, " | ") + "]"
 		case n == "sample_index":
 			st := sampleTypes(p)
 			if v == "" {
 		}
 		args = append(args, fmt.Sprintf("  %-25s = %-20s %s", n, v, comment))
 	}
-	for g, vars := range groups {
-		sort.Strings(vars.values)
-		comment := commentStart + " [" + strings.Join(vars.values, " | ") + "]"
-		args = append(args, fmt.Sprintf("  %-25s = %-20s %s", g, vars.set, comment))
-	}
 	sort.Strings(args)
 	ui.Print(strings.Join(args, "\n"))
 }
 
 // parseCommandLine parses a command and returns the pprof command to
-// execute and a set of variables for the report.
-func parseCommandLine(input []string) ([]string, variables, error) {
+// execute and the configuration to use for the report.
+func parseCommandLine(input []string) ([]string, config, error) {
 	cmd, args := input[:1], input[1:]
 	name := cmd[0]
 
 		}
 	}
 	if c == nil {
-		if v := pprofVariables[name]; v != nil {
-			return nil, nil, fmt.Errorf("did you mean: %s=%s", name, args[0])
+		if _, ok := configHelp[name]; ok {
+			value := "<val>"
+			if len(args) > 0 {
+				value = args[0]
+			}
+			return nil, config{}, fmt.Errorf("did you mean: %s=%s", name, value)
 		}
-		return nil, nil, fmt.Errorf("unrecognized command: %q", name)
+		return nil, config{}, fmt.Errorf("unrecognized command: %q", name)
 	}
 
 	if c.hasParam {
 		if len(args) == 0 {
-			return nil, nil, fmt.Errorf("command %s requires an argument", name)
+			return nil, config{}, fmt.Errorf("command %s requires an argument", name)
 		}
 		cmd = append(cmd, args[0])
 		args = args[1:]
 	}
 
-	// Copy the variables as options set in the command line are not persistent.
-	vcopy := pprofVariables.makeCopy()
+	// Copy config since options set in the command line should not persist.
+	vcopy := currentConfig()
 
 	var focus, ignore string
 	for i := 0; i < len(args); i++ {
 		t := args[i]
-		if _, err := strconv.ParseInt(t, 10, 32); err == nil {
-			vcopy.set("nodecount", t)
+		if n, err := strconv.ParseInt(t, 10, 32); err == nil {
+			vcopy.NodeCount = int(n)
 			continue
 		}
 		switch t[0] {
 			if outputFile == "" {
 				i++
 				if i >= len(args) {
-					return nil, nil, fmt.Errorf("unexpected end of line after >")
+					return nil, config{}, fmt.Errorf("unexpected end of line after >")
 				}
 				outputFile = args[i]
 			}
-			vcopy.set("output", outputFile)
+			vcopy.Output = outputFile
 		case '-':
 			if t == "--cum" || t == "-cum" {
-				vcopy.set("cum", "t")
+				vcopy.Sort = "cum"
 				continue
 			}
 			ignore = catRegex(ignore, t[1:])
 	}
 
 	if name == "tags" {
-		updateFocusIgnore(vcopy, "tag", focus, ignore)
+		if focus != "" {
+			vcopy.TagFocus = focus
+		}
+		if ignore != "" {
+			vcopy.TagIgnore = ignore
+		}
 	} else {
-		updateFocusIgnore(vcopy, "", focus, ignore)
+		if focus != "" {
+			vcopy.Focus = focus
+		}
+		if ignore != "" {
+			vcopy.Ignore = ignore
+		}
 	}
-
-	if vcopy["nodecount"].intValue() == -1 && (name == "text" || name == "top") {
-		vcopy.set("nodecount", "10")
+	if vcopy.NodeCount == -1 && (name == "text" || name == "top") {
+		vcopy.NodeCount = 10
 	}
 
 	return cmd, vcopy, nil
 }
 
-func updateFocusIgnore(v variables, prefix, f, i string) {
-	if f != "" {
-		focus := prefix + "focus"
-		v.set(focus, catRegex(v[focus].value, f))
-	}
-
-	if i != "" {
-		ignore := prefix + "ignore"
-		v.set(ignore, catRegex(v[ignore].value, i))
-	}
-}
-
 func catRegex(a, b string) string {
 	if a != "" && b != "" {
 		return a + "|" + b
 		return
 	}
 
-	if v := pprofVariables[args]; v != nil {
-		ui.Print(v.help + "\n")
+	if help, ok := configHelp[args]; ok {
+		ui.Print(help + "\n")
 		return
 	}
 
 // newCompleter creates an autocompletion function for a set of commands.
 func newCompleter(fns []string) func(string) string {
 	return func(line string) string {
-		v := pprofVariables
 		switch tokens := strings.Fields(line); len(tokens) {
 		case 0:
 			// Nothing to complete
 		case 1:
 			// Single token -- complete command name
-			if match := matchVariableOrCommand(v, tokens[0]); match != "" {
+			if match := matchVariableOrCommand(tokens[0]); match != "" {
 				return match
 			}
 		case 2:
 			if tokens[0] == "help" {
-				if match := matchVariableOrCommand(v, tokens[1]); match != "" {
+				if match := matchVariableOrCommand(tokens[1]); match != "" {
 					return tokens[0] + " " + match
 				}
 				return line
 }
 
 // matchVariableOrCommand attempts to match a string token to the prefix of a Command.
-func matchVariableOrCommand(v variables, token string) string {
+func matchVariableOrCommand(token string) string {
 	token = strings.ToLower(token)
-	found := ""
+	var matches []string
 	for cmd := range pprofCommands {
 		if strings.HasPrefix(cmd, token) {
-			if found != "" {
-				return ""
-			}
-			found = cmd
+			matches = append(matches, cmd)
 		}
 	}
-	for variable := range v {
-		if strings.HasPrefix(variable, token) {
-			if found != "" {
-				return ""
-			}
-			found = variable
-		}
+	matches = append(matches, completeConfig(token)...)
+	if len(matches) == 1 {
+		return matches[0]
 	}
-	return found
+	return ""
 }
 
 // functionCompleter replaces provided substring with a function

internal/driver/interactive_test.go

 	savedCommands, pprofCommands = pprofCommands, testCommands
 	defer func() { pprofCommands = savedCommands }()
 
-	savedVariables := pprofVariables
-	defer func() { pprofVariables = savedVariables }()
+	savedConfig := currentConfig()
+	defer setCurrentConfig(savedConfig)
 
 	shortcuts1, scScript1 := makeShortcuts(interleave(script, 2), 1)
 	shortcuts2, scScript2 := makeShortcuts(interleave(script, 1), 2)
 		{"Random interleave of independent scripts 2", interleave(script, 1), pprofShortcuts, "", 0, false},
 		{"Random interleave of independent scripts with shortcuts 1", scScript1, shortcuts1, "", 0, false},
 		{"Random interleave of independent scripts with shortcuts 2", scScript2, shortcuts2, "", 0, false},
-		{"Group with invalid value", []string{"cumulative=this"}, pprofShortcuts, `unrecognized value for cumulative: "this". Use one of cum, flat`, 1, false},
+		{"Group with invalid value", []string{"sort=this"}, pprofShortcuts, `invalid "sort" value`, 1, false},
 		{"No special value provided for the option", []string{"sample_index"}, pprofShortcuts, `please specify a value, e.g. sample_index=<val>`, 1, false},
-		{"No string value provided for the option", []string{"focus="}, pprofShortcuts, `please specify a value, e.g. focus=<val>`, 1, false},
+		{"No string value provided for the option", []string{"focus"}, pprofShortcuts, `please specify a value, e.g. focus=<val>`, 1, false},
 		{"No float value provided for the option", []string{"divide_by"}, pprofShortcuts, `please specify a value, e.g. divide_by=<val>`, 1, false},
 		{"Helpful input format reminder", []string{"sample_index 0"}, pprofShortcuts, `did you mean: sample_index=0`, 1, false},
 		{"Verify propagation of IO errors", []string{"**error**"}, pprofShortcuts, "", 0, true},
 	o := setDefaults(&plugin.Options{HTTPTransport: transport.New(nil)})
 	for _, tc := range testcases {
 		t.Run(tc.name, func(t *testing.T) {
-			pprofVariables = testVariables(savedVariables)
+			setCurrentConfig(savedConfig)
 			pprofShortcuts = tc.shortcuts
 			ui := &proftest.TestUI{
 				T:       t,
 	"check": &command{report.Raw, nil, nil, true, "", ""},
 }
 
-func testVariables(base variables) variables {
-	v := base.makeCopy()
-
-	v["b"] = &variable{boolKind, "f", "", ""}
-	v["bb"] = &variable{boolKind, "f", "", ""}
-	v["i"] = &variable{intKind, "0", "", ""}
-	v["ii"] = &variable{intKind, "0", "", ""}
-	v["f"] = &variable{floatKind, "0", "", ""}
-	v["ff"] = &variable{floatKind, "0", "", ""}
-	v["s"] = &variable{stringKind, "", "", ""}
-	v["ss"] = &variable{stringKind, "", "", ""}
-
-	v["ta"] = &variable{boolKind, "f", "radio", ""}
-	v["tb"] = &variable{boolKind, "f", "radio", ""}
-	v["tc"] = &variable{boolKind, "t", "radio", ""}
-
-	return v
-}
-
 // script contains sequences of commands to be executed for testing. Commands
 // are split by semicolon and interleaved randomly, so they must be
 // independent from each other.
 var script = []string{
-	"bb=true;bb=false;check bb=false;bb=yes;check bb=true",
-	"b=1;check b=true;b=n;check b=false",
-	"i=-1;i=-2;check i=-2;i=999999;check i=999999",
-	"check ii=0;ii=-1;check ii=-1;ii=100;check ii=100",
-	"f=-1;f=-2.5;check f=-2.5;f=0.0001;check f=0.0001",
-	"check ff=0;ff=-1.01;check ff=-1.01;ff=100;check ff=100",
-	"s=one;s=two;check s=two",
-	"ss=tree;check ss=tree;ss=forest;check ss=forest",
-	"ta=true;check ta=true;check tb=false;check tc=false;tb=1;check tb=true;check ta=false;check tc=false;tc=yes;check tb=false;check ta=false;check tc=true",
+	"call_tree=true;call_tree=false;check call_tree=false;call_tree=yes;check call_tree=true",
+	"mean=1;check mean=true;mean=n;check mean=false",
+	"nodecount=-1;nodecount=-2;check nodecount=-2;nodecount=999999;check nodecount=999999",
+	"nodefraction=-1;nodefraction=-2.5;check nodefraction=-2.5;nodefraction=0.0001;check nodefraction=0.0001",
+	"focus=one;focus=two;check focus=two",
+	"flat=true;check sort=flat;cum=1;check sort=cum",
 }
 
 func makeShortcuts(input []string, seed int) (shortcuts, []string) {
 	return s, output
 }
 
-func checkValue(p *profile.Profile, cmd []string, vars variables, o *plugin.Options) error {
+func checkValue(p *profile.Profile, cmd []string, cfg config, o *plugin.Options) error {
 	if len(cmd) != 2 {
 		return fmt.Errorf("expected len(cmd)==2, got %v", cmd)
 	}
 		value = args[1]
 	}
 
-	gotv := vars[name]
-	if gotv == nil {
+	f, ok := configFieldMap[name]
+	if !ok {
 		return fmt.Errorf("Could not find variable named %s", name)
 	}
 
-	if got := gotv.stringValue(); got != value {
+	if got := cfg.get(f); got != value {
 		return fmt.Errorf("Variable %s, want %s, got %s", name, value, got)
 	}
 	return nil
 		{
 			"top 10 --cum focus1 -ignore focus2",
 			map[string]string{
-				"functions": "true",
-				"nodecount": "10",
-				"cum":       "true",
-				"focus":     "focus1|focus2",
-				"ignore":    "ignore",
+				"granularity": "functions",
+				"nodecount":   "10",
+				"sort":        "cum",
+				"focus":       "focus1|focus2",
+				"ignore":      "ignore",
 			},
 		},
 		{
 			"top10 --cum focus1 -ignore focus2",
 			map[string]string{
-				"functions": "true",
-				"nodecount": "10",
-				"cum":       "true",
-				"focus":     "focus1|focus2",
-				"ignore":    "ignore",
+				"granularity": "functions",
+				"nodecount":   "10",
+				"sort":        "cum",
+				"focus":       "focus1|focus2",
+				"ignore":      "ignore",
 			},
 		},
 		{
 			"dot",
 			map[string]string{
-				"functions": "true",
-				"nodecount": "80",
-				"cum":       "false",
+				"granularity": "functions",
+				"nodecount":   "80",
+				"sort":        "flat",
 			},
 		},
 		{
 			"tags   -ignore1 -ignore2 focus1 >out",
 			map[string]string{
-				"functions": "true",
-				"nodecount": "80",
-				"cum":       "false",
-				"output":    "out",
-				"tagfocus":  "focus1",
-				"tagignore": "ignore1|ignore2",
+				"granularity": "functions",
+				"nodecount":   "80",
+				"sort":        "flat",
+				"output":      "out",
+				"tagfocus":    "focus1",
+				"tagignore":   "ignore1|ignore2",
 			},
 		},
 		{
 			"weblist  find -test",
 			map[string]string{
-				"functions": "false",
-				"addresses": "true",
-				"noinlines": "true",
-				"nodecount": "0",
-				"cum":       "false",
-				"flat":      "true",
-				"ignore":    "test",
+				"granularity": "addresses",
+				"noinlines":   "true",
+				"nodecount":   "0",
+				"sort":        "flat",
+				"ignore":      "test",
 			},
 		},
 		{
 			"callgrind   fun -ignore  >out",
 			map[string]string{
-				"functions": "false",
-				"addresses": "true",
-				"nodecount": "0",
-				"cum":       "false",
-				"flat":      "true",
-				"output":    "out",
+				"granularity": "addresses",
+				"nodecount":   "0",
+				"sort":        "flat",
+				"output":      "out",
 			},
 		},
 		{
 	}
 
 	for _, tc := range testcases {
-		cmd, vars, err := parseCommandLine(strings.Fields(tc.input))
+		cmd, cfg, err := parseCommandLine(strings.Fields(tc.input))
 		if tc.want == nil && err != nil {
 			// Error expected
 			continue
 		if c == nil {
 			t.Fatalf("unexpected nil command")
 		}
-		vars = applyCommandOverrides(cmd[0], c.format, vars)
+		cfg = applyCommandOverrides(cmd[0], c.format, cfg)
 
 		for n, want := range tc.want {
-			if got := vars[n].stringValue(); got != want {
+			if got := cfg.get(configFieldMap[n]); got != want {
 				t.Errorf("failed on %q, cmd=%q, %s got %s, want %s", tc.input, cmd, n, got, want)
 			}
 		}

internal/driver/settings.go

+package driver
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path/filepath"
+)
+
+// settings holds pprof settings.
+type settings struct {
+	// Configs holds a list of named UI configurations.
+	Configs []namedConfig `json:"configs"`
+}
+
+// namedConfig associates a name with a config.
+type namedConfig struct {
+	Name string `json:"name"`
+	config
+}
+
+// settingsFileName returns the name of the file where settings should be saved.
+func settingsFileName() (string, error) {
+	// Return "pprof/settings.json" under os.UserConfigDir().
+	dir, err := os.UserConfigDir()
+	if err != nil {
+		return "", err
+	}
+	dir = filepath.Join(dir, "pprof")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, "settings.json"), nil
+}
+
+// readSettings reads settings from fname.
+func readSettings(fname string) (*settings, error) {
+	data, err := ioutil.ReadFile(fname)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &settings{}, nil
+		}
+		return nil, fmt.Errorf("could not read settings: %w", err)
+	}
+	settings := &settings{}
+	if err := json.Unmarshal(data, settings); err != nil {
+		return nil, fmt.Errorf("could not parse settings: %w", err)
+	}
+	for i := range settings.Configs {
+		settings.Configs[i].resetTransient()
+	}
+	return settings, nil
+}
+
+// writeSettings saves settings to fname.
+func writeSettings(fname string, settings *settings) error {
+	data, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return fmt.Errorf("could not encode settings: %w", err)
+	}
+	if err := ioutil.WriteFile(fname, data, 0644); err != nil {
+		return fmt.Errorf("failed to write settings: %w", err)
+	}
+	return nil
+}
+
+// configMenuEntry holds information for a single config menu entry.
+type configMenuEntry struct {
+	Name       string
+	URL        string
+	Current    bool // Is this the currently selected config?
+	UserConfig bool // Is this a user-provided config?
+}
+
+// configMenu returns a list of items to add to a menu in the web UI.
+func configMenu(fname string, url url.URL) []configMenuEntry {
+	// Start with system configs.
+	configs := []namedConfig{{Name: "Default", config: defaultConfig()}}
+	if settings, err := readSettings(fname); err == nil {
+		// Add user configs.
+		configs = append(configs, settings.Configs...)
+	}
+
+	// Convert to menu entries.
+	result := make([]configMenuEntry, len(configs))
+	lastMatch := -1
+	for i, cfg := range configs {
+		dst, changed := cfg.config.makeURL(url)
+		if !changed {
+			lastMatch = i
+		}
+		result[i] = configMenuEntry{
+			Name:       cfg.Name,
+			URL:        dst.String(),
+			UserConfig: (i != 0),
+		}
+	}
+	// Mark the last matching config as currennt
+	if lastMatch >= 0 {
+		result[lastMatch].Current = true
+	}
+	return result
+}
+
+// editSettings edits settings by applying fn to them.
+func editSettings(fname string, fn func(s *settings) error) error {
+	settings, err := readSettings(fname)
+	if err != nil {
+		return err
+	}
+	if err := fn(settings); err != nil {
+		return err
+	}
+	return writeSettings(fname, settings)
+}
+
+// setConfig saves the config specified in request to fname.
+func setConfig(fname string, request url.URL) error {
+	q := request.Query()
+	name := q.Get("config")
+	if name == "" {
+		return fmt.Errorf("invalid config name")
+	}
+	cfg := currentConfig()
+	if err := cfg.applyURL(q); err != nil {
+		return err
+	}
+	return editSettings(fname, func(s *settings) error {
+		for i, c := range s.Configs {
+			if c.Name == name {
+				s.Configs[i].config = cfg
+				return nil
+			}
+		}
+		s.Configs = append(s.Configs, namedConfig{Name: name, config: cfg})
+		return nil
+	})
+}
+
+// removeConfig removes config from fname.
+func removeConfig(fname, config string) error {
+	return editSettings(fname, func(s *settings) error {
+		for i, c := range s.Configs {
+			if c.Name == config {
+				s.Configs = append(s.Configs[:i], s.Configs[i+1:]...)
+				return nil
+			}
+		}
+		return fmt.Errorf("config %s not found", config)
+	})
+}

internal/driver/settings_test.go

+package driver
+
+import (
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// settingsDirAndFile returns a directory in which settings should be stored
+// and the name of the settings file. The caller must delete the directory when
+// done.
+func settingsDirAndFile(t *testing.T) (string, string) {
+	tmpDir, err := ioutil.TempDir("", "pprof_settings_test")
+	if err != nil {
+		t.Fatalf("error creating temporary directory: %v", err)
+	}
+	return tmpDir, filepath.Join(tmpDir, "settings.json")
+}
+
+func TestSettings(t *testing.T) {
+	tmpDir, fname := settingsDirAndFile(t)
+	defer os.RemoveAll(tmpDir)
+	s, err := readSettings(fname)
+	if err != nil {
+		t.Fatalf("error reading empty settings: %v", err)
+	}
+	if len(s.Configs) != 0 {
+		t.Fatalf("expected empty settings; got %v", s)
+	}
+	s.Configs = append(s.Configs, namedConfig{
+		Name: "Foo",
+		config: config{
+			Focus: "focus",
+			// Ensure that transient fields are not saved/restored.
+			Output:     "output",
+			SourcePath: "source",
+			TrimPath:   "trim",
+			DivideBy:   -2,
+		},
+	})
+	if err := writeSettings(fname, s); err != nil {
+		t.Fatal(err)
+	}
+	s2, err := readSettings(fname)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Change the transient fields to their expected values.
+	s.Configs[0].resetTransient()
+	if !reflect.DeepEqual(s, s2) {
+		t.Fatalf("ReadSettings = %v; expected %v", s2, s)
+	}
+}
+
+func TestParseConfig(t *testing.T) {
+	// Use all the fields to check they are saved/restored from URL.
+	cfg := config{
+		Output:              "",
+		DropNegative:        true,
+		CallTree:            true,
+		RelativePercentages: true,
+		Unit:                "auto",
+		CompactLabels:       true,
+		SourcePath:          "",
+		TrimPath:            "",
+		NodeCount:           10,
+		NodeFraction:        0.1,
+		EdgeFraction:        0.2,
+		Trim:                true,
+		Focus:               "focus",
+		Ignore:              "ignore",
+		PruneFrom:           "prune_from",
+		Hide:                "hide",
+		Show:                "show",
+		ShowFrom:            "show_from",
+		TagFocus:            "tagfocus",
+		TagIgnore:           "tagignore",
+		TagShow:             "tagshow",
+		TagHide:             "taghide",
+		DivideBy:            1,
+		Mean:                true,
+		Normalize:           true,
+		Sort:                "cum",
+		Granularity:         "functions",
+		NoInlines:           true,
+	}
+	url, changed := cfg.makeURL(url.URL{})
+	if !changed {
+		t.Error("applyConfig returned changed=false after applying non-empty config")
+	}
+	cfg2 := defaultConfig()
+	if err := cfg2.applyURL(url.Query()); err != nil {
+		t.Fatalf("fromURL failed: %v", err)
+	}
+	if !reflect.DeepEqual(cfg, cfg2) {
+		t.Fatalf("parsed config = %+v; expected match with %+v", cfg2, cfg)
+	}
+	if url2, changed := cfg.makeURL(url); changed {
+		t.Errorf("ApplyConfig returned changed=true after applying same config (%q instead of expected %q", url2.String(), url.String())
+	}
+}
+
+// TestDefaultConfig verifies that default config values are omitted from URL.
+func TestDefaultConfig(t *testing.T) {
+	cfg := defaultConfig()
+	url, changed := cfg.makeURL(url.URL{})
+	if changed {
+		t.Error("applyConfig returned changed=true after applying default config")
+	}
+	if url.String() != "" {
+		t.Errorf("applyConfig returned %q; expecting %q", url.String(), "")
+	}
+}
+
+func TestConfigMenu(t *testing.T) {
+	// Save some test settings.
+	tmpDir, fname := settingsDirAndFile(t)
+	defer os.RemoveAll(tmpDir)
+	a, b := defaultConfig(), defaultConfig()
+	a.Focus, b.Focus = "foo", "bar"
+	s := &settings{
+		Configs: []namedConfig{
+			{Name: "A", config: a},
+			{Name: "B", config: b},
+		},
+	}
+	if err := writeSettings(fname, s); err != nil {
+		t.Fatal("error writing settings", err)
+	}
+
+	pageURL, _ := url.Parse("/top?f=foo")
+	menu := configMenu(fname, *pageURL)
+	want := []configMenuEntry{
+		{Name: "Default", URL: "/top", Current: false, UserConfig: false},
+		{Name: "A", URL: "/top?f=foo", Current: true, UserConfig: true},
+		{Name: "B", URL: "/top?f=bar", Current: false, UserConfig: true},
+	}
+	if !reflect.DeepEqual(menu, want) {
+		t.Errorf("ConfigMenu returned %v; want %v", menu, want)
+	}
+}
+
+func TestEditConfig(t *testing.T) {
+	tmpDir, fname := settingsDirAndFile(t)
+	defer os.RemoveAll(tmpDir)
+
+	type testConfig struct {
+		name  string
+		focus string
+		hide  string
+	}
+	type testCase struct {
+		remove  bool
+		request string
+		expect  []testConfig
+	}
+	for _, c := range []testCase{
+		// Create setting c1
+		{false, "/?config=c1&f=foo", []testConfig{
+			{"c1", "foo", ""},
+		}},
+		// Create setting c2
+		{false, "/?config=c2&h=bar", []testConfig{
+			{"c1", "foo", ""},
+			{"c2", "", "bar"},
+		}},
+		// Overwrite c1
+		{false, "/?config=c1&f=baz", []testConfig{
+			{"c1", "baz", ""},
+			{"c2", "", "bar"},
+		}},
+		// Delete c2
+		{true, "c2", []testConfig{
+			{"c1", "baz", ""},
+		}},
+	} {
+		if c.remove {
+			if err := removeConfig(fname, c.request); err != nil {
+				t.Errorf("error removing config %s: %v", c.request, err)
+				continue
+			}
+		} else {
+			req, err := url.Parse(c.request)
+			if err != nil {
+				t.Errorf("error parsing request %q: %v", c.request, err)
+				continue
+			}
+			if err := setConfig(fname, *req); err != nil {
+				t.Errorf("error saving request %q: %v", c.request, err)
+				continue
+			}
+		}
+
+		// Check resulting settings.
+		s, err := readSettings(fname)
+		if err != nil {
+			t.Errorf("error reading settings after applying %q: %v", c.request, err)
+			continue
+		}
+		// Convert to a list that can be compared to c.expect
+		got := make([]testConfig, len(s.Configs))
+		for i, c := range s.Configs {
+			got[i] = testConfig{c.Name, c.Focus, c.Hide}
+		}
+		if !reflect.DeepEqual(got, c.expect) {
+			t.Errorf("Settings after applying %q = %v; want %v", c.request, got, c.expect)
+		}
+	}
+}
+
+func TestAssign(t *testing.T) {
+	baseConfig := currentConfig()
+	defer setCurrentConfig(baseConfig)
+
+	// Test assigning to a simple field.
+	if err := configure("nodecount", "20"); err != nil {
+		t.Errorf("error setting nodecount: %v", err)
+	}
+	if n := currentConfig().NodeCount; n != 20 {
+		t.Errorf("incorrect nodecount; expecting 20, got %d", n)
+	}
+
+	// Test assignment to a group field.
+	if err := configure("granularity", "files"); err != nil {
+		t.Errorf("error setting granularity: %v", err)
+	}
+	if g := currentConfig().Granularity; g != "files" {
+		t.Errorf("incorrect granularity; expecting %v, got %v", "files", g)
+	}
+
+	// Test assignment to one choice of a group field.
+	if err := configure("lines", "t"); err != nil {
+		t.Errorf("error setting lines: %v", err)
+	}
+	if g := currentConfig().Granularity; g != "lines" {
+		t.Errorf("incorrect granularity; expecting %v, got %v", "lines", g)
+	}
+
+	// Test assignment to invalid choice,
+	if err := configure("granularity", "cheese"); err == nil {
+		t.Errorf("allowed assignment of invalid granularity")
+	}
+}

internal/driver/webhtml.go

   color: gray;
   pointer-events: none;
 }
+.menu-check-mark {
+  position: absolute;
+  left: 2px;
+}
+.menu-delete-btn {
+  position: absolute;
+  right: 2px;
+}
+
+{{/* Used to disable events when a modal dialog is displayed */}}
+#dialog-overlay {
+  display: none;
+  position: fixed;
+  left: 0px;
+  top: 0px;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(1,1,1,0.1);
+}
+
+.dialog {
+  {{/* Displayed centered horizontally near the top */}}
+  display: none;
+  position: fixed;
+  margin: 0px;
+  top: 60px;
+  left: 50%;
+  transform: translateX(-50%);
+
+  z-index: 3;
+  font-size: 125%;
+  background-color: #ffffff;
+  box-shadow: 0 1px 5px rgba(0,0,0,.3);
+}
+.dialog-header {
+  font-size: 120%;
+  border-bottom: 1px solid #CCCCCC;
+  width: 100%;
+  text-align: center;
+  background: #EEEEEE;
+  user-select: none;
+}
+.dialog-footer {
+  border-top: 1px solid #CCCCCC;
+  width: 100%;
+  text-align: right;
+  padding: 10px;
+}
+.dialog-error {
+  margin: 10px;
+  color: red;
+}
+.dialog input {
+  margin: 10px;
+  font-size: inherit;
+}
+.dialog button {
+  margin-left: 10px;
+  font-size: inherit;
+}
+#save-dialog, #delete-dialog {
+  width: 50%;
+  max-width: 20em;
+}
+#delete-prompt {
+  padding: 10px;
+}
 
 #content {
   overflow-y: scroll;
     </div>
   </div>
 
+  <div id="config" class="menu-item">
+    <div class="menu-name">
+      Config
+      <i class="downArrow"></i>
+    </div>
+    <div class="submenu">
+      <a title="{{.Help.save_config}}" id="save-config">Save as ...</a>
+      <hr>
+      {{range .Configs}}
+        <a href="{{.URL}}">
+          {{if .Current}}<span class="menu-check-mark">✓</span>{{end}}
+          {{.Name}}
+          {{if .UserConfig}}<span class="menu-delete-btn" data-config={{.Name}}>🗙</span>{{end}}
+        </a>
+      {{end}}
+    </div>
+  </div>
+
   <div>
     <input id="search" type="text" placeholder="Search regexp" autocomplete="off" autocapitalize="none" size=40>
   </div>
   </div>
 </div>
 
+<div id="dialog-overlay"></div>
+
+<div class="dialog" id="save-dialog">
+  <div class="dialog-header">Save options as</div>
+  <datalist id="config-list">
+    {{range .Configs}}{{if .UserConfig}}<option value="{{.Name}}" />{{end}}{{end}}
+  </datalist>
+  <input id="save-name" type="text" list="config-list" placeholder="New config" />
+  <div class="dialog-footer">
+    <span class="dialog-error" id="save-error"></span>
+    <button id="save-cancel">Cancel</button>
+    <button id="save-confirm">Save</button>
+  </div>
+</div>
+
+<div class="dialog" id="delete-dialog">
+  <div class="dialog-header" id="delete-dialog-title">Delete config</div>
+  <div id="delete-prompt"></div>
+  <div class="dialog-footer">
+    <span class="dialog-error" id="delete-error"></span>
+    <button id="delete-cancel">Cancel</button>
+    <button id="delete-confirm">Delete</button>
+  </div>
+</div>
+
 <div id="errors">{{range .Errors}}<div>{{.}}</div>{{end}}</div>
 {{end}}
 
   }, { passive: true, capture: true });
 }
 
+function sendURL(method, url, done) {
+  fetch(url.toString(), {method: method})
+      .then((response) => { done(response.ok); })
+      .catch((error) => { done(false); });
+}
+
+// Initialize handlers for saving/loading configurations.
+function initConfigManager() {
+  'use strict';
+
+  // Initialize various elements.
+  function elem(id) {
+    const result = document.getElementById(id);
+    if (!result) console.warn('element ' + id + ' not found');
+    return result;
+  }
+  const overlay = elem('dialog-overlay');
+  const saveDialog = elem('save-dialog');
+  const saveInput = elem('save-name');
+  const saveError = elem('save-error');
+  const delDialog = elem('delete-dialog');
+  const delPrompt = elem('delete-prompt');
+  const delError = elem('delete-error');
+
+  let currentDialog = null;
+  let currentDeleteTarget = null;
+
+  function showDialog(dialog) {
+    if (currentDialog != null) {
+      overlay.style.display = 'none';
+      currentDialog.style.display = 'none';
+    }
+    currentDialog = dialog;
+    if (dialog != null) {
+      overlay.style.display = 'block';
+      dialog.style.display = 'block';
+    }
+  }
+
+  function cancelDialog(e) {
+    showDialog(null);
+  }
+
+  // Show dialog for saving the current config.
+  function showSaveDialog(e) {
+    saveError.innerText = '';
+    showDialog(saveDialog);
+    saveInput.focus();
+  }
+
+  // Commit save config.
+  function commitSave(e) {
+    const name = saveInput.value;
+    const url = new URL(document.URL);
+    // Set path relative to existing path.
+    url.pathname = new URL('./saveconfig', document.URL).pathname;
+    url.searchParams.set('config', name);
+    saveError.innerText = '';
+    sendURL('POST', url, (ok) => {
+      if (!ok) {
+        saveError.innerText = 'Save failed';
+      } else {
+        showDialog(null);
+        location.reload();  // Reload to show updated config menu
+      }
+    });
+  }
+
+  function handleSaveInputKey(e) {
+    if (e.key === 'Enter') commitSave(e);
+  }
+
+  function deleteConfig(e, elem) {
+    e.preventDefault();
+    const config = elem.dataset.config;
+    delPrompt.innerText = 'Delete ' + config + '?';
+    currentDeleteTarget = elem;
+    showDialog(delDialog);
+  }
+
+  function commitDelete(e, elem) {
+    if (!currentDeleteTarget) return;
+    const config = currentDeleteTarget.dataset.config;
+    const url = new URL('./deleteconfig', document.URL);
+    url.searchParams.set('config', config);
+    delError.innerText = '';
+    sendURL('DELETE', url, (ok) => {
+      if (!ok) {
+        delError.innerText = 'Delete failed';
+        return;
+      }
+      showDialog(null);
+      // Remove menu entry for this config.
+      if (currentDeleteTarget && currentDeleteTarget.parentElement) {
+        currentDeleteTarget.parentElement.remove();
+      }
+    });
+  }
+
+  // Bind event on elem to fn.
+  function bind(event, elem, fn) {
+    if (elem == null) return;
+    elem.addEventListener(event, fn);
+    if (event == 'click') {
+      // Also enable via touch.
+      elem.addEventListener('touchstart', fn);
+    }
+  }
+
+  bind('click', elem('save-config'), showSaveDialog);
+  bind('click', elem('save-cancel'), cancelDialog);
+  bind('click', elem('save-confirm'), commitSave);
+  bind('keydown', saveInput, handleSaveInputKey);
+
+  bind('click', elem('delete-cancel'), cancelDialog);
+  bind('click', elem('delete-confirm'), commitDelete);
+
+  // Activate deletion button for all config entries in menu.
+  for (const del of Array.from(document.getElementsByClassName('menu-delete-btn'))) {
+    bind('click', del, (e) => {
+      deleteConfig(e, del);
+    });
+  }
+}
+
 function viewer(baseUrl, nodes) {
   'use strict';
 
   }
 
   addAction('details', handleDetails);
+  initConfigManager();
 
   search.addEventListener('input', handleSearch);
   search.addEventListener('keydown', handleKey);

internal/driver/webui.go

 
 // webInterface holds the state needed for serving a browser based interface.
 type webInterface struct {
-	prof      *profile.Profile
-	options   *plugin.Options
-	help      map[string]string
-	templates *template.Template
+	prof         *profile.Profile
+	options      *plugin.Options
+	help         map[string]string
+	templates    *template.Template
+	settingsFile string
 }
 
-func makeWebInterface(p *profile.Profile, opt *plugin.Options) *webInterface {
+func makeWebInterface(p *profile.Profile, opt *plugin.Options) (*webInterface, error) {
+	settingsFile, err := settingsFileName()
+	if err != nil {
+		return nil, err
+	}
 	templates := template.New("templategroup")
 	addTemplates(templates)
 	report.AddSourceTemplates(templates)
 	return &webInterface{
-		prof:      p,
-		options:   opt,
-		help:      make(map[string]string),
-		templates: templates,
-	}
+		prof:         p,
+		options:      opt,
+		help:         make(map[string]string),
+		templates:    templates,
+		settingsFile: settingsFile,
+	}, nil
 }
 
 // maxEntries is the maximum number of entries to print for text interfaces.
 	TextBody    string
 	Top         []report.TextItem
 	FlameGraph  template.JS
+	Configs     []configMenuEntry
 }
 
 func serveWebInterface(hostport string, p *profile.Profile, o *plugin.Options, disableBrowser bool) error {
 		return err
 	}
 	interactiveMode = true
-	ui := makeWebInterface(p, o)
+	ui, err := makeWebInterface(p, o)
+	if err != nil {
+		return err
+	}
 	for n, c := range pprofCommands {
 		ui.help[n] = c.description
 	}
-	for n, v := range pprofVariables {
-		ui.help[n] = v.help
+	for n, help := range configHelp {
+		ui.help[n] = help
 	}
 	ui.help["details"] = "Show information about the profile and this view"
 	ui.help["graph"] = "Display profile as a directed graph"
 	ui.help["reset"] = "Show the entire profile"
+	ui.help["save_config"] = "Save current settings"
 
 	server := o.HTTPServer
 	if server == nil {
 		Host:     host,
 		Port:     port,
 		Handlers: map[string]http.Handler{
-			"/":           http.HandlerFunc(ui.dot),
-			"/top":        http.HandlerFunc(ui.top),
-			"/disasm":     http.HandlerFunc(ui.disasm),
-			"/source":     http.HandlerFunc(ui.source),
-			"/peek":       http.HandlerFunc(ui.peek),
-			"/flamegraph": http.HandlerFunc(ui.flamegraph),
+			"/":             http.HandlerFunc(ui.dot),
+			"/top":          http.HandlerFunc(ui.top),
+			"/disasm":       http.HandlerFunc(ui.disasm),
+			"/source":       http.HandlerFunc(ui.source),
+			"/peek":         http.HandlerFunc(ui.peek),
+			"/flamegraph":   http.HandlerFunc(ui.flamegraph),
+			"/saveconfig":   http.HandlerFunc(ui.saveConfig),
+			"/deleteconfig": http.HandlerFunc(ui.deleteConfig),
 		},
 	}
 
 
 func openBrowser(url string, o *plugin.Options) {
 	// Construct URL.
-	u, _ := gourl.Parse(url)
-	q := u.Query()
-	for _, p := range []struct{ param, key string }{
-		{"f", "focus"},
-		{"s", "show"},
-		{"sf", "show_from"},
-		{"i", "ignore"},
-		{"h", "hide"},
-		{"si", "sample_index"},
-	} {
-		if v := pprofVariables[p.key].value; v != "" {
-			q.Set(p.param, v)
-		}
-	}
-	u.RawQuery = q.Encode()
+	baseURL, _ := gourl.Parse(url)
+	current := currentConfig()
+	u, _ := current.makeURL(*baseURL)
 
 	// Give server a little time to get ready.
 	time.Sleep(time.Millisecond * 500)
 	o.UI.PrintErr(u.String())
 }
 
-func varsFromURL(u *gourl.URL) variables {
-	vars := pprofVariables.makeCopy()
-	vars["focus"].value = u.Query().Get("f")
-	vars["show"].value = u.Query().Get("s")
-	vars["show_from"].value = u.Query().Get("sf")
-	vars["ignore"].value = u.Query().Get("i")
-	vars["hide"].value = u.Query().Get("h")
-	vars["sample_index"].value = u.Query().Get("si")
-	return vars
-}
-
 // makeReport generates a report for the specified command.
+// If configEditor is not null, it is used to edit the config used for the report.
 func (ui *webInterface) makeReport(w http.ResponseWriter, req *http.Request,
-	cmd []string, vars ...string) (*report.Report, []string) {
-	v := varsFromURL(req.URL)
-	for i := 0; i+1 < len(vars); i += 2 {
-		v[vars[i]].value = vars[i+1]
+	cmd []string, configEditor func(*config)) (*report.Report, []string) {
+	cfg := currentConfig()
+	if err := cfg.applyURL(req.URL.Query()); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		ui.options.UI.PrintErr(err)
+		return nil, nil
+	}
+	if configEditor != nil {
+		configEditor(&cfg)
 	}
 	catcher := &errorCatcher{UI: ui.options.UI}
 	options := *ui.options
 	options.UI = catcher
-	_, rpt, err := generateRawReport(ui.prof, cmd, v, &options)
+	_, rpt, err := generateRawReport(ui.prof, cmd, cfg, &options)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		ui.options.UI.PrintErr(err)
 }
 
 // render generates html using the named template based on the contents of data.
-func (ui *webInterface) render(w http.ResponseWriter, tmpl string,
+func (ui *webInterface) render(w http.ResponseWriter, req *http.Request, tmpl string,
 	rpt *report.Report, errList, legend []string, data webArgs) {
 	file := getFromLegend(legend, "File: ", "unknown")
 	profile := getFromLegend(legend, "Type: ", "unknown")
 	data.SampleTypes = sampleTypes(ui.prof)
 	data.Legend = legend
 	data.Help = ui.help
+	data.Configs = configMenu(ui.settingsFile, *req.URL)
+
 	html := &bytes.Buffer{}
 	if err := ui.templates.ExecuteTemplate(html, tmpl, data); err != nil {
 		http.Error(w, "internal template error", http.StatusInternalServerError)
 
 // dot generates a web page containing an svg diagram.
 func (ui *webInterface) dot(w http.ResponseWriter, req *http.Request) {
-	rpt, errList := ui.makeReport(w, req, []string{"svg"})
+	rpt, errList := ui.makeReport(w, req, []string{"svg"}, nil)
 	if rpt == nil {
 		return // error already reported
 	}
 		nodes = append(nodes, n.Info.Name)
 	}
 
-	ui.render(w, "graph", rpt, errList, legend, webArgs{
+	ui.render(w, req, "graph", rpt, errList, legend, webArgs{
 		HTMLBody: template.HTML(string(svg)),
 		Nodes:    nodes,
 	})
 }
 
 func (ui *webInterface) top(w http.ResponseWriter, req *http.Request) {
-	rpt, errList := ui.makeReport(w, req, []string{"top"}, "nodecount", "500")
+	rpt, errList := ui.makeReport(w, req, []string{"top"}, func(cfg *config) {
+		cfg.NodeCount = 500
+	})
 	if rpt == nil {
 		return // error already reported
 	}
 		nodes = append(nodes, item.Name)
 	}
 
-	ui.render(w, "top", rpt, errList, legend, webArgs{
+	ui.render(w, req, "top", rpt, errList, legend, webArgs{
 		Top:   top,
 		Nodes: nodes,
 	})
 // disasm generates a web page containing disassembly.
 func (ui *webInterface) disasm(w http.ResponseWriter, req *http.Request) {
 	args := []string{"disasm", req.URL.Query().Get("f")}
-	rpt, errList := ui.makeReport(w, req, args)
+	rpt, errList := ui.makeReport(w, req, args, nil)
 	if rpt == nil {
 		return // error already reported
 	}
 	}
 
 	legend := report.ProfileLabels(rpt)
-	ui.render(w, "plaintext", rpt, errList, legend, webArgs{
+	ui.render(w, req, "plaintext", rpt, errList, legend, webArgs{
 		TextBody: out.String(),
 	})
 
 // data.
 func (ui *webInterface) source(w http.ResponseWriter, req *http.Request) {
 	args := []string{"weblist", req.URL.Query().Get("f")}
-	rpt, errList := ui.makeReport(w, req, args)
+	rpt, errList := ui.makeReport(w, req, args, nil)
 	if rpt == nil {
 		return // error already reported
 	}
 	}
 
 	legend := report.ProfileLabels(rpt)
-	ui.render(w, "sourcelisting", rpt, errList, legend, webArgs{
+	ui.render(w, req, "sourcelisting", rpt, errList, legend, webArgs{
 		HTMLBody: template.HTML(body.String()),
 	})
 }
 // peek generates a web page listing callers/callers.
 func (ui *webInterface) peek(w http.ResponseWriter, req *http.Request) {
 	args := []string{"peek", req.URL.Query().Get("f")}
-	rpt, errList := ui.makeReport(w, req, args, "lines", "t")
+	rpt, errList := ui.makeReport(w, req, args, func(cfg *config) {
+		cfg.Granularity = "lines"
+	})
 	if rpt == nil {
 		return // error already reported
 	}
 	}
 
 	legend := report.ProfileLabels(rpt)
-	ui.render(w, "plaintext", rpt, errList, legend, webArgs{
+	ui.render(w, req, "plaintext", rpt, errList, legend, webArgs{
 		TextBody: out.String(),
 	})
 }
 
+// saveConfig saves URL configuration.
+func (ui *webInterface) saveConfig(w http.ResponseWriter, req *http.Request) {
+	if err := setConfig(ui.settingsFile, *req.URL); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		ui.options.UI.PrintErr(err)
+		return
+	}
+}
+
+// deleteConfig deletes a configuration.
+func (ui *webInterface) deleteConfig(w http.ResponseWriter, req *http.Request) {
+	name := req.URL.Query().Get("config")
+	if err := removeConfig(ui.settingsFile, name); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		ui.options.UI.PrintErr(err)
+		return
+	}
+}
+
 // getFromLegend returns the suffix of an entry in legend that starts
 // with param.  It returns def if no such entry is found.
 func getFromLegend(legend []string, param, def string) string {

internal/driver/webui_test.go

 	// Start server and wait for it to be initialized
 	go serveWebInterface("unused:1234", prof, &plugin.Options{
 		Obj:        fakeObjTool{},
-		UI:         &proftest.TestUI{},
+		UI:         &proftest.TestUI{T: t},
 		HTTPServer: creator,
 	}, false)
 	<-serverCreated