← Back to branch summary

~jetsaredim/firefox-extensions/firebug.upstream

« back to all changes in this revision

Viewing changes to content/firebug/.svn/text-base/sourceCache.js.svn-base

  • Committer: Jared Greenwald
  • Date: 2008-04-22 18:20:42 UTC
  • Revision ID: jgreenwa@4lom-20080422182042-90kbumm805h2hjt6
 * new upstream source (v1.2~b21+svn572)

Show diffs side-by-side

added added

removed removed

Lines of Context:
content/firebug/.svn/text-base/sourceCache.js.svn-base
1
 
/* See license.txt for terms of usage */
2
 
 
3
 
FBL.ns(function() { with (FBL) {
4
 
 
5
 
// ************************************************************************************************
6
 
// Constants
7
 
 
8
 
const nsIIOService = CI("nsIIOService");
9
 
const nsIRequest = CI("nsIRequest");
10
 
const nsICachingChannel = CI("nsICachingChannel");
11
 
const nsIScriptableInputStream = CI("nsIScriptableInputStream");
12
 
const nsIUploadChannel = CI("nsIUploadChannel");
13
 
 
14
 
const IOService = CC("@mozilla.org/network/io-service;1");
15
 
const ScriptableInputStream = CC("@mozilla.org/scriptableinputstream;1");
16
 
 
17
 
const LOAD_FROM_CACHE = nsIRequest.LOAD_FROM_CACHE;
18
 
const LOAD_BYPASS_LOCAL_CACHE_IF_BUSY = nsICachingChannel.LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
19
 
 
20
 
const NS_BINDING_ABORTED = 0x804b0002;
21
 
 
22
 
// ************************************************************************************************
23
 
 
24
 
top.SourceCache = function(context)
25
 
{
26
 
    this.context = context;
27
 
    this.cache = {};
28
 
};
29
 
 
30
 
top.SourceCache.prototype =
31
 
{
32
 
    loadText: function(url)
33
 
    {
34
 
        var lines = this.load(url);
35
 
        return lines ? lines.join("\n") : null;
36
 
    },
37
 
 
38
 
    load: function(url)
39
 
    {
40
 
        if (url in this.cache)
41
 
            return this.cache[url];
42
 
 
43
 
        var d = FBL.reDataURL.exec(url);
44
 
        if (d)
45
 
        {
46
 
            var src = url.substring(FBL.reDataURL.lastIndex);
47
 
            var data = decodeURIComponent(src);
48
 
            var lines = data.split(/\r\n|\r|\n/);
49
 
            this.cache[url] = lines;
50
 
 
51
 
            return lines;
52
 
        }
53
 
 
54
 
        var j = FBL.reJavascript.exec(url);
55
 
        if (j)
56
 
        {
57
 
            var src = url.substring(FBL.reJavascript.lastIndex);
58
 
            var lines = src.split(/\r\n|\r|\n/);
59
 
            this.cache[url] = lines;
60
 
 
61
 
            return lines;
62
 
        }
63
 
 
64
 
        var charset = this.context.window.document.characterSet;
65
 
 
66
 
        var ioService = IOService.getService(nsIIOService);
67
 
 
68
 
        var channel;
69
 
        try
70
 
        {
71
 
            channel = ioService.newChannel(url, null, null);
72
 
            channel.loadFlags |= LOAD_FROM_CACHE | LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
73
 
        }
74
 
        catch (exc)
75
 
        {
76
 
            ERROR("sourceCache.load fails newChannel for url="+url+ " cause:"+exc+"\n");
77
 
            return;
78
 
        }
79
 
 
80
 
        if (url == this.context.browser.contentWindow.location.href)
81
 
        {
82
 
            if (channel instanceof nsIUploadChannel)
83
 
            {
84
 
                var postData = getPostStream(this.context);
85
 
                if (postData)
86
 
                {
87
 
                    var uploadChannel = QI(channel, nsIUploadChannel);
88
 
                    uploadChannel.setUploadStream(postData, "", -1);
89
 
                }
90
 
            }
91
 
 
92
 
            if (channel instanceof nsICachingChannel)
93
 
            {
94
 
                var cacheChannel = QI(channel, nsICachingChannel);
95
 
                cacheChannel.cacheKey = getCacheKey(this.context);
96
 
            }
97
 
        }
98
 
 
99
 
        var stream;
100
 
        try
101
 
        {
102
 
            stream = channel.open();
103
 
        }
104
 
        catch (exc)
105
 
        {
106
 
 
107
 
            if (FBL.reChrome.test(url))  // chrome urls cannot be read with this code.
108
 
                return;
109
 
            return;
110
 
        }
111
 
 
112
 
        try
113
 
        {
114
 
            var data = readFromStream(stream, charset);
115
 
            var lines = data.split(/\r\n|\r|\n/);
116
 
            this.cache[url] = lines;
117
 
            return lines;
118
 
        }
119
 
        catch (exc)
120
 
        {
121
 
        }
122
 
        finally
123
 
        {
124
 
            stream.close();
125
 
        }
126
 
    },
127
 
 
128
 
    loadAsync: function(url, cb)
129
 
    {
130
 
        if (url in this.cache)
131
 
        {
132
 
            cb(this.cache[url], url);
133
 
            return;
134
 
        }
135
 
 
136
 
        var ioService = IOService.getService(nsIIOService);
137
 
 
138
 
        var channel = ioService.newChannel(url, null, null);
139
 
        channel.loadFlags |= LOAD_FROM_CACHE | LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
140
 
 
141
 
        var listener = new StreamListener(url, this, cb);
142
 
        channel.asyncOpen(listener, null);
143
 
    },
144
 
 
145
 
    store: function(url, text)
146
 
    {
147
 
        var lines = splitLines(text);
148
 
        return this.cache[url] = lines;
149
 
    },
150
 
 
151
 
    invalidate: function(url)
152
 
    {
153
 
        delete this.cache[url];
154
 
    },
155
 
 
156
 
    getLine: function(url, lineNo)
157
 
    {
158
 
        var lines = this.load(url);
159
 
        return lines ? lines[lineNo-1] : null;
160
 
    },
161
 
 
162
 
    getLineAsync: function(url, lineNo, cb)
163
 
    {
164
 
        if (url in this.cache)
165
 
            cb(this.cache[url][lineNo-1], url, lineNo);
166
 
        else
167
 
        {
168
 
            function loader(lines, url)
169
 
            {
170
 
                cb(lines[lineNo-1], url, lineNo);
171
 
            }
172
 
 
173
 
            this.loadAsync(url, loader);
174
 
        }
175
 
    }
176
 
};
177
 
 
178
 
// ************************************************************************************************
179
 
 
180
 
function StreamListener(url, cache, cb)
181
 
{
182
 
    this.url = url;
183
 
    this.cache = cache;
184
 
    this.cb = cb;
185
 
    this.data = [];
186
 
}
187
 
 
188
 
StreamListener.prototype =
189
 
{
190
 
    onStartRequest: function(request, context)
191
 
    {
192
 
    },
193
 
 
194
 
    onStopRequest: function(request, context, status)
195
 
    {
196
 
        this.done = true;
197
 
 
198
 
        if (status != NS_BINDING_ABORTED)
199
 
        {
200
 
            var data = this.data.join("");
201
 
            var lines = this.cache.store(this.url, data);
202
 
            this.cb(lines, this.url, status);
203
 
        }
204
 
    },
205
 
 
206
 
    onDataAvailable: function(request, context, inStr, sourceOffset, count)
207
 
    {
208
 
        var sis = ScriptableInputStream.createInstance(nsIScriptableInputStream);
209
 
        sis.init(inStr);
210
 
        this.data.push(sis.read(count));
211
 
    }
212
 
};
213
 
 
214
 
// ************************************************************************************************
215
 
 
216
 
function getPostStream(context)
217
 
{
218
 
    try
219
 
    {
220
 
        var webNav = context.browser.webNavigation;
221
 
        var descriptor = QI(webNav, CI("nsIWebPageDescriptor")).currentDescriptor;
222
 
        var entry = QI(descriptor, CI("nsISHEntry"));
223
 
 
224
 
        if (entry.postData)
225
 
        {
226
 
            // Seek to the beginning, or it will probably start reading at the end
227
 
            var postStream = QI(entry.postData, CI("nsISeekableStream"));
228
 
            postStream.seek(0, 0);
229
 
 
230
 
            return postStream;
231
 
        }
232
 
 
233
 
     }
234
 
     catch (exc)
235
 
     {
236
 
     }
237
 
}
238
 
 
239
 
function getCacheKey(context)
240
 
{
241
 
    try
242
 
    {
243
 
        var webNav = context.browser.webNavigation;
244
 
        var descriptor = QI(webNav, CI("nsIWebPageDescriptor")).currentDescriptor;
245
 
        var entry = QI(descriptor, CI("nsISHEntry"));
246
 
        return entry.cacheKey;
247
 
     }
248
 
     catch (exc)
249
 
     {
250
 
     }
251
 
}
252
 
 
253
 
// ************************************************************************************************
254
 
 
255
 
}});