I have multiple sets of code listed below.  The first is my initial attempt to do the charting, without using the GoogleViz (and related components).  The second set of code is an example (and supporting utility Color class) for using the GoogleViz component -- though it would need to be modified/genericed as needed.

The code below is a very "manual" way of creating the chart w/o using the GoogleViz libraries.

public class GoogleChartsUtilities {
	
	public static final String BASE_URL = 'https://chart.googleapis.com/chart?';
	public static final String CHART_TYPE_PARAM = 'cht=';
	public static final String CHART_TITLE_PARAM = 'chtt=';
	public static final String CHART_GRID_PARAM = 'chg=';
	public static final String CHART_COLORS_PARAM = 'chco=';
	public static final String CHART_SIZE_PARAM = 'chs=';
	public static final String CHART_AXIS_PARAM = 'chxt=';
	public static final String CHART_AXIS_RANGE_PARAM = 'chxr=';
	public static final String CHART_BAR_STYLE_PARAM = 'chbh=';
	public static final String CHART_AXIS_LABEL_PARAM = 'chxl=';
	public static final String CHART_LEGEND_PARAM = 'chdl=';
	public static final String CHART_LEGEND_POSITION_PARAM = 'chdlp=';
	public static final String CHART_DATA_PARAM = 'chd=t:';
	public static final String CHART_SCALE_PARAM = 'chds=';
	
	private static final Map<Integer,String> HEX_MAP = new Map<Integer,String>();	
	static {
		HEX_MAP.put(0,'0');
		HEX_MAP.put(1,'1');
		HEX_MAP.put(2,'2');
		HEX_MAP.put(3,'3');
		HEX_MAP.put(4,'4');
		HEX_MAP.put(5,'5');
		HEX_MAP.put(6,'6');
		HEX_MAP.put(7,'7');
		HEX_MAP.put(8,'8');
		HEX_MAP.put(9,'9');
		HEX_MAP.put(10,'A');
		HEX_MAP.put(11,'B');
		HEX_MAP.put(12,'C');
		HEX_MAP.put(13,'D');
		HEX_MAP.put(14,'E');
		HEX_MAP.put(15,'F');
	}
	
	/**
		Create a Matrix-style Bar Chart, each bar represents a Grouping (Major), and segments(Minor) within that group are stacked
		Requires a List of AggregateResult objects representing each Major/Minor Grouping of data.
		e.g.:
		Video - Basic Video
		Video - Extended Video
		Video - Extremem Video
		HSD - Slow
		HSD - Fast
		
		Returns a Map of Chart Parameters to their values.  This allows the caller to override and add parameters
		as desired.
	*/
	public static Map<String,String> constructMatrixBarGoogleChart(
		List<AggregateResult> aggregateResultList, 
		String majorGroupFieldName, 
		String minorGroupFieldName, 
		String summaryFieldName,
		String chartTitle,
		String chartSizeDimensions)
	{
		//The final value to be returned
		Map<String,String> chartParameterToValues = new Map<String,String>();
		
		//Working Variables to Hold constructed values
		String CHART_COLORS_VAL = '';
		String CHART_AXIS_RANGE_VAL = '';
		String CHART_AXIS_LABEL_VAL = '';
		String CHART_LEGEND_VAL = '';
		String CHART_DATA_VAL = '';
		String CHART_SCALE_VAL = '';
		
		//Map in defaulted parameters
		chartParameterToValues.put(CHART_TYPE_PARAM, 'bvs');
		chartParameterToValues.put(CHART_TITLE_PARAM, chartTitle);
		chartParameterToValues.put(CHART_SIZE_PARAM, chartSizeDimensions);
		chartParameterToValues.put(CHART_BAR_STYLE_PARAM, 'r,1,1');
		chartParameterToValues.put(CHART_LEGEND_POSITION_PARAM, 'b|a');
		
		String majorBarGrouping = '';
		Map<String,List<MinorSubgroupingSummaryVO>> majorToMinortoSummary = new Map<String,List<MinorSubgroupingSummaryVO>>(); 
		
		Integer countDistinctMajorGroups = 0;
		Integer maxMajorMinorEntrieSize = 0;
		Integer currentRguServiceSize = 0;
		
		Double largestMajorTotalAmount = 0;
		Double currentMajorTotalAmount = 0;
		Map<String,Double> majorGroupToTotalSummaryAmount = new Map<String,Double>();
		
		for (AggregateResult ar : aggregateResultList){
			String majorGroupValue = (String)ar.get(majorGroupFieldName);
			String subgroupName = (String)ar.get(minorGroupFieldName);
			String summaryValue = String.valueOf(ar.get(summaryFieldName));
			
			MinorSubgroupingSummaryVO currentMinorGroupSummaryVO = new MinorSubgroupingSummaryVO();
			currentMinorGroupSummaryVO.subgroupName = subgroupName;
			currentMinorGroupSummaryVO.valueSummary = summaryValue;
			
			System.debug('majorGroupValue:'+ majorGroupValue + ' - subgroupName:'+ subgroupName + ' - summaryValue:'+ summaryValue);
			//establish/update counts
			if(majorGroupValue != majorBarGrouping){
				
				//majorGroupValue changed so increase unique majorGroupValue's AND indicate new Service Size
				countDistinctMajorGroups++;
				if(currentRguServiceSize > maxMajorMinorEntrieSize){
					maxMajorMinorEntrieSize = currentRguServiceSize;
				}
				if(currentMajorTotalAmount > largestMajorTotalAmount){
					largestMajorTotalAmount = currentMajorTotalAmount;
				}
			
				currentRguServiceSize = 1; //reset the currentRguServiceSize
				currentMajorTotalAmount = Double.valueOf(summaryValue); //
				majorBarGrouping = majorGroupValue; //set the new majorGroupValue as the previous for the next round
				
			}
			else{
				//continue by adding another amount to current RguServiceSize
				currentRguServiceSize++;
				currentMajorTotalAmount += Double.valueOf(summaryValue);
			}
			
			//update data
			if(majorToMinortoSummary.containsKey(majorGroupValue)){
				System.debug('Found entry for key: ' + majorGroupValue);
				List<MinorSubgroupingSummaryVO> myMinorSubgroupSummaryVoList = majorToMinortoSummary.get(majorGroupValue);
				myMinorSubgroupSummaryVoList.add(currentMinorGroupSummaryVO);
				
			}
			else{
				//initialize
				System.debug('New majorGroupValue: ' + majorGroupValue);
				List<MinorSubgroupingSummaryVO> myMinorSubgroupSummaryVoList = new List<MinorSubgroupingSummaryVO>();
				myMinorSubgroupSummaryVoList.add(currentMinorGroupSummaryVO);
				majorToMinortoSummary.put(majorGroupValue, myMinorSubgroupSummaryVoList);
			}
			
		}
		
		System.debug('countDistinctMajorGroups:' + countDistinctMajorGroups + ' - maxMajorMinorEntrieSize:' + maxMajorMinorEntrieSize);
		System.debug('majorToMinortoSummary: ' + majorToMinortoSummary);
		

		//for now use the GET URL style.  Eventually this needs to be converted as a post, and probably passed along to Javascript?
		//set CHART_DATA_VAL, CHART_LEGEND_VAL, and CHART_COLORS_VAL
		//loop through all of the Major entries, based on the maxMajorMinorEntrieSize
		Set<String> majorKeys = majorToMinortoSummary.keySet();
		
		//develop colors for each bar/series
		Map<String, List<String>> mapMajorGroupToColorSeries = new Map<String, List<String>>();
		for(String key : majorKeys){
			List<String> colorsForBar = GoogleChartsUtilities.getDataSetColors(maxMajorMinorEntrieSize);
			mapMajorGroupToColorSeries.put(key, colorsForBar);
		}
		
		for(Integer loopCount = 0; loopCount < maxMajorMinorEntrieSize; loopCount++){
			System.debug('On Loop Count: ' + loopCount);
			boolean isFirst = true;
			for(String key : majorKeys){
				if(isFirst){
					isFirst = false;
				}
				else{
					CHART_DATA_VAL += ',';
					CHART_LEGEND_VAL += ',';
					CHART_COLORS_VAL += '|';
				}
				System.debug('Working with key: ' + key);
				List<MinorSubgroupingSummaryVO> myMinorSubgroupSummaryVoList = majorToMinortoSummary.get(key);
				System.debug('Located list, size=' + myMinorSubgroupSummaryVoList.size());
				if(loopCount < myMinorSubgroupSummaryVoList.size()){
					MinorSubgroupingSummaryVO srsVo = myMinorSubgroupSummaryVoList.get(loopCount);
					CHART_DATA_VAL += srsVo.valueSummary;
					CHART_LEGEND_VAL += srsVo.subgroupName;
					CHART_COLORS_VAL += mapMajorGroupToColorSeries.get(key).get(loopCount);
				}
				else{
					//There shouldn't be data available for this specific item in the series
					CHART_DATA_VAL +=  '0';
					CHART_LEGEND_VAL += 'N/A';
					CHART_COLORS_VAL += mapMajorGroupToColorSeries.get(key).get(loopCount);
				}
			}
			if(loopCount+1 < maxMajorMinorEntrieSize){
				CHART_DATA_VAL +=  '|';
				CHART_LEGEND_VAL += '|';
				CHART_COLORS_VAL += ',';
			}
		}

		chartParameterToValues.put(CHART_DATA_PARAM, CHART_DATA_VAL);
		chartParameterToValues.put(CHART_COLORS_PARAM, CHART_COLORS_VAL);
		
		//Define the Chart Scale Parameters
		chartParameterToValues.put(CHART_SCALE_PARAM, '1,' + largestMajorTotalAmount);
		
		//Define Axis Param/Range/Scale/Labels
		chartParameterToValues.put(CHART_AXIS_PARAM, 'x,y');
		chartParameterToValues.put(CHART_AXIS_RANGE_PARAM, '1,0,' + largestMajorTotalAmount);
		
		
		String xAxisLabelFormatString = '0:|';
		//re-use majorKeys above as the X-Axis Labels
		for(String key : majorKeys){
			xAxisLabelFormatString += key += '|';
		}
		chartParameterToValues.put(CHART_AXIS_LABEL_PARAM, xAxisLabelFormatString);
		
		System.debug('Generated Map: ' + chartParameterToValues);
		return chartParameterToValues;	
	}
	
	public static String constructGoogleChartUrl(Map<String,String> chartParamValueMap, boolean useRandomChartServer){
		String url = '';
		//Determine the Chart Server Base URL
		if(useRandomChartServer){
			Integer serverNumber = Math.Round(Math.Random() * 9);
			url += 'https://' + serverNumber + '.chart.googleapis.com/chart?';
		}
		else{
			url += BASE_URL;
		}
		
		boolean isFirst = true;
		for(String key : chartParamValueMap.keySet()){
			if(isFirst){
				//no '&'
				url += key + chartParamValueMap.get(key);
				isFirst=false;
			}
			else{
				url += '&' + key + chartParamValueMap.get(key);
			}
		}
		return url;
	}
	
	/**
		Produces a series of colors that should be used for a data set (bar) in our chart
	*/
	public static List<String> getDataSetColors(Integer maxNumberOfDataPoints){
		//First we need to determine a strong base color based on two or the RGB parameters
		//Which two?
		Integer firstRgbIndex = Math.round(2 * Math.random());
		Integer secondRgbIndex = firstRgbIndex;
		Integer thirdRgbIndex = 2;
		while(firstRgbIndex == secondRgbIndex){
			secondRgbIndex = Math.round(2 * Math.random());
		}
		//determine the third, variable RGB color index
		if(firstRgbIndex != 0 && secondRgbIndex != 0){
			thirdRgbIndex = 0;
		}
		else if(firstRgbIndex !=1 && secondRgbIndex != 1){
			thirdRgbIndex = 1;
		}	
		
		Integer firstRgbColor = 0;
		Integer secondRgbColor = 0;
		String firstRgbColorHex = '';
		String secondRgbColorHex = '';
		//Second, generate the actual strong colors for the rbg indexes
		//Going to use min/max values of 128-255 (88-FF)
		firstRgbColor = Math.round(128 + (127 * Math.random()));
		secondRgbColor = Math.round(128 + (127 * Math.random()));
		//Convert these to Hexadecimal Values
		firstRgbColorHex = convertIntegerToHexadecimal(firstRgbColor);
		secondRgbColorHex = convertIntegerToHexadecimal(secondRgbColor);
		
		Map<Integer, String> rgbToBaseColorIndexMap = new Map<Integer, String>();
		rgbToBaseColorIndexMap.put(firstRgbIndex, firstRgbColorHex);
		rgbToBaseColorIndexMap.put(secondRgbIndex, secondRgbColorHex);
		
		
		//Now, generate a series of *visible* hex values for the third datapoint (0-200?)
		Integer interval = Math.round(200/maxNumberOfDataPoints - 1); //minus 1 because the first value will always be 0
		
		List<String> thirdHexColorList = new List<String>();
		thirdHexColorList.add('00');//00 will always be the staring value, and variants are added
		for(Integer intervalCount = 1; intervalCount<maxNumberOfDataPoints;intervalCount++){		
			thirdHexColorList.add(convertIntegerToHexadecimal(interval * intervalCount));
		}
		System.debug('thirdHexColorList: ' + thirdHexColorList);
		
		
		List<String> colorsForBar = new List<String>();
		//Add variant colors
		for(Integer colorListCount=0; colorListCount < thirdHexColorList.size(); colorListCount++){
			String finalColor = '000000';
			//first hex
			if(firstRgbIndex == 0){
				finalColor=firstRgbColorHex;
			}
			else if(secondRgbIndex == 0){
				finalColor=secondRgbColorHex;
			}
			else{
				finalColor=thirdHexColorList.get(colorListCount);
			}
			//second hex
			if(firstRgbIndex == 1){
				finalColor+=firstRgbColorHex;
			}
			else if(secondRgbIndex == 1){
				finalColor+=secondRgbColorHex;
			}
			else{
				finalColor+=thirdHexColorList.get(colorListCount);
			}
			//third hex
			if(firstRgbIndex == 2){
				finalColor+=firstRgbColorHex;
			}
			else if(secondRgbIndex == 2){
				finalColor+=secondRgbColorHex;
			}
			else{
				finalColor+=thirdHexColorList.get(colorListCount);
			}
			colorsForBar.add(finalColor);
		}
		
		return colorsForBar;
	}
	
	//Expected to be a value between 0 and 255
	public static String convertIntegerToHexadecimal(Integer value){
		Integer modFirstCharacterNumber = Math.mod(value, 16);
		Integer firstCharacterNumber = (value - modFirstCharacterNumber)/16;
		String firstCharacterHexcode = HEX_MAP.get(firstCharacterNumber);
		String secondCharacterHexcode = HEX_MAP.get(modFirstCharacterNumber);
		String hexValue = '';
		hexValue = firstCharacterHexcode + secondCharacterHexcode;
		
		return hexValue;
	}
	
	/** Inner container class for services' revenue values */
	class MinorSubgroupingSummaryVO{
		public String subgroupName {get;set;}
		public String valueSummary {get;set;}
	}
}